package com.xzx.gc.user.service;

import cn.hutool.core.codec.Base64;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Dict;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.aliyuncs.exceptions.ClientException;
import com.xzx.gc.common.constant.CommonEnum;
import com.xzx.gc.common.constant.Constants;
import com.xzx.gc.common.constant.UserEnum;
import com.xzx.gc.common.utils.IdUtils;
import com.xzx.gc.common.utils.RedisUtil;
import com.xzx.gc.common.utils.SpringUtil;
import com.xzx.gc.common.utils.ali.SmsUtil;
import com.xzx.gc.entity.*;
import com.xzx.gc.model.user.AddressReq;
import com.xzx.gc.model.user.UserInfoVo;
import com.xzx.gc.model.user.UserReq;
import com.xzx.gc.user.mapper.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import tk.mybatis.mapper.entity.Example;

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

@Service
@Transactional
@Slf4j
public class UserLoginService{


    @Autowired
    private UserMapper userMapper;

    @Autowired
    private IdUtils idUtils;

    @Autowired
    private AccountMapper accountMapper;

    @Autowired
    private UserLoginInfoMapper userLoginInfoMapper;

    @Autowired
    private AmqpTemplate amqpTemplate;

    @Autowired
    private UserService userService;

    @Autowired
    private UserStatService userStatService;


    @Autowired
    private UserTargetInfoMapper userTargetInfoMapper;

    @Autowired
    private UserTargetInfoService userTargetInfoService;


    @Autowired
    private HttpServletRequest request;

    @Autowired
    private UserShareInfoMapper userShareInfoMapper;

    @Autowired
    private AddressService addressService;

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private  OtherUserService otherUserService;

    @Autowired
    private ConfigMapper configMapper;

    @Autowired
    private AccountService accountService;




    
    public String getVerifyCode(String phoneNum,int smsType) throws ClientException {
        //生成文字验证码
        String code = RandomUtil.randomNumbers(5);

        //将token与用户手机号关联
        redisUtil.setex(Constants.REDIS_USER_KEY +"code:"+ phoneNum, code, 60);


        ConfigInfo configInfo=new ConfigInfo();
        configInfo.setConfigTypeCode("SMS_CHANNEL");
        ConfigInfo configInfo1 = configMapper.selectOne(configInfo);
        String configValue = configInfo1.getConfigValue();

        //轮询发送方式
        String channel = redisUtil.get(Constants.REDIS_USER_KEY + "code:channel:" + phoneNum);
        if(channel!=null){
            if(channel.equals(CommonEnum.阿里云短信.getValue())){
                configValue=CommonEnum.助通短信.getValue();
            }else{
                configValue=CommonEnum.阿里云短信.getValue();
            }
        }


        String templateCode="";

        //0 登录 1忘记密码 2自助下单
        if(smsType==0){
            if(CommonEnum.阿里云短信.getValue().equals(configValue)) {
                templateCode = Constants.LOGIN_SMS_TEMPLATE;
            }else if(CommonEnum.助通短信.getValue().equals(configValue)){
                templateCode = Constants.LOGIN_SMS_ZT_TEMPLATE;
            }
            redisUtil.set(Constants.REDIS_USER_KEY + "code:channel:" + phoneNum,configValue);
        }else if(smsType==1){
            if(CommonEnum.阿里云短信.getValue().equals(configValue)) {
                templateCode=Constants.UPDATE_PWD_SMS_TEMPLATE;
            }else if(CommonEnum.助通短信.getValue().equals(configValue)){
                templateCode=Constants.UPDATE_PWD_SMS_ZT_TEMPLATE;
            }
            redisUtil.set(Constants.REDIS_USER_KEY + "code:channel:" + phoneNum,configValue);
        }else if(smsType==2){
            if(CommonEnum.阿里云短信.getValue().equals(configValue)) {
                templateCode=Constants.ORDER_SMS_TEMPLATE;
            }else if(CommonEnum.助通短信.getValue().equals(configValue)){
                templateCode=Constants.ORDER_SMS_ZT_TEMPLATE;
            }
        }


        Map map = new HashMap();
        if(CommonEnum.阿里云短信.getValue().equals(configValue)) {
            map.put("code", code);
        }else if(CommonEnum.助通短信.getValue().equals(configValue)){
            map.put( "valid_code", code);
        }
        String send = SmsUtil.send(phoneNum, map, templateCode, configValue);

        if(send!=null){
            return send;
        }
        return "0";
    }



    
    public int login(UserReq userReq) {
        int notCheckLoginFlag = userReq.getNotCheckLoginFlag();
        if(StringUtils.isBlank(userReq.getOpenId())){
            return -4;
        }

        if(StringUtils.isNotBlank(userReq.getNickName())){
            if(!com.xzx.gc.common.utils.StringUtils.isBase64(userReq.getNickName())){
                userReq.setNickName(Base64.encode(userReq.getNickName()));
            }
        }
        String mobilePhone = userReq.getMobilePhone();
        String verifyCode = userReq.getVerifyCode();
        int returnvalue=0;
        //同一微信登录只能对应一个手机号码
        String existMobilePhone = userMapper.isUniqueByMobilePhone(userReq);
        if (existMobilePhone!=null && !existMobilePhone.equals(userReq.getMobilePhone())){
            //同一微信登录只能对应一个手机号码
            log.warn("同一微信登录只能对应一个手机号码,open:{},mobile:{}",userReq.getOpenId(),userReq.getMobilePhone());
            return -3;
        }

        //将token与用户手机号关联
        if(SpringUtil.isProdOrCloud()&&notCheckLoginFlag==0) {
            String redisVerifyCode=null;

            redisVerifyCode = redisUtil.get(Constants.REDIS_USER_KEY+"code:" + mobilePhone);

            if (StringUtils.isBlank(redisVerifyCode)) {
                //验证码已经超过有效期2分钟
                return -1;
            }

            if (!redisVerifyCode.equals(verifyCode)) {
                //验证码错误
                return -2;
            }
        }

        //普通用户则插入一条用户记录
        //根据手机号或userid查询
        List<UserInfoVo> phoneNum=userService.queryUserInfo(userReq);
        if (!CollectionUtils.isEmpty(phoneNum)){
            //更新用户信息
            UserInfo userInfo=new UserInfo();
            userInfo.setCity(userReq.getCity());
            userInfo.setProvince(userReq.getProvince());
            userInfo.setCountry(userReq.getCountry());
            userInfo.setSex(userReq.getSex());
            userInfo.setAvatar(userReq.getAvatar());
            userInfo.setNickName(userReq.getNickName());
            userInfo.setOpenId(userReq.getOpenId());
            userInfo.setLatitude(userReq.getLatitude());
            userInfo.setLongitude(userReq.getLongitude());
            userInfo.setRegistType(Convert.toShort(CommonEnum.正常注册用户.getValue()));
            Example example=new Example(UserInfo.class);
            example.createCriteria().andEqualTo("mobilePhone",phoneNum.get(0).getMobilePhone());
            userMapper.updateByExampleSelective(userInfo,example);
            log.info("用户登录成功，ID:{},手机号：{}",phoneNum.get(0).getUserId(),phoneNum.get(0).getMobilePhone());
        }else {

                //进行关系绑定
                if(StrUtil.isNotBlank(userReq.getRegisterMobilePhone())){
                    UserShareInfo userShareInfo = new UserShareInfo();
                    //邀请人
                    userShareInfo.setMobilePhone(userReq.getRegisterMobilePhone());
                    //被邀请人
                    userShareInfo.setRegisterMobilePhone(userReq.getMobilePhone());
                    //同一个人
                    if(!userShareInfo.getMobilePhone().equals(userShareInfo.getRegisterMobilePhone())){
                        //被邀请人已经被邀请了
                        UserShareInfo userShareInfo1=new UserShareInfo();
                        userShareInfo1.setRegisterMobilePhone(userShareInfo.getRegisterMobilePhone());
                        List<UserShareInfo> select = userShareInfoMapper.select(userShareInfo1);
                        if(CollUtil.isEmpty(select)){
                            //邀请人不能在平台存在别的角色
                            List<OtherUserInfo> byMobile = otherUserService.findByMobile(userShareInfo.getMobilePhone());
                            if(CollUtil.isEmpty(byMobile)) {
                                userShareInfo.setRegisterTime(DateUtil.now());
                                userShareInfoMapper.insertSelective(userShareInfo);
                                log.info("用户绑定成功，邀请人:{},被邀请人:{}", userShareInfo.getMobilePhone(), userShareInfo.getRegisterMobilePhone());
                            }else{
                                log.warn("邀请人：{}不是普通用户",userShareInfo.getMobilePhone());
                            }
                        }
                    }
                }


                UserInfo userInfo = new UserInfo();
                BeanUtils.copyProperties(userReq, userInfo);
                userInfo.setRegistTime(DateUtil.now());
                userInfo.setDelFlag(0);
                String userId=idUtils.generate("YH",3);
                userInfo.setUserId(userId);
                userInfo.setRegistType(Convert.toShort(CommonEnum.正常注册用户.getValue()));
                userInfo.setUserType(CommonEnum.普通用户.getValue());
                userMapper.insertSelective(userInfo);

                //是否被推广
                List<UserTargetInfo> byMobile = userTargetInfoService.findByMobile(mobilePhone);

                if(CollUtil.isNotEmpty(byMobile)){
                    //修改目标客户的状态
                    UserTargetInfo userTargetInfo=new UserTargetInfo();
                    userTargetInfo.setRegsterType(Convert.toInt(UserEnum.已注册.getValue()));
                    userTargetInfo.setNickName(userInfo.getNickName());
                    userTargetInfo.setUserImage(userInfo.getAvatar());
                    Example example2=new Example(UserTargetInfo.class);
                    example2.createCriteria().andEqualTo("mobile",mobilePhone);
                    userTargetInfoMapper.updateByExampleSelective(userTargetInfo,example2);


                    for (UserTargetInfo info : byMobile) {
                        AddressReq addressReq=new AddressReq();
                        addressReq.setUserId(userInfo.getUserId());
                        if(StrUtil.isNotBlank(info.getDetailAddress())&&StrUtil.isNotBlank(info.getAddressArea())){
                            addressReq.setOrigin(1);
                            addAddress(info,addressReq);
                        }
                    }

                }

                //增加一个默认账户
                returnvalue = accountService.addDefault(userReq.getMobilePhone(),userInfo.getUserId());
                log.debug("用户注册成功，ID:{},手机号：{}",userId,mobilePhone);
        }
        return returnvalue;

    }


    /**
     * 添加地址
     * @param userTargetInfo
     */
    private void addAddress(UserTargetInfo userTargetInfo,AddressReq addressReq) {
        //同步添加用户默认地址。
        addressReq.setMobilePhone(userTargetInfo.getMobile());

        addressReq.setDetailAddress(userTargetInfo.getDetailAddress());


        addressReq.setAddressArea(userTargetInfo.getAddressArea());


        addressReq.setProvinceId(userTargetInfo.getProvinceId());
        addressReq.setCityId(userTargetInfo.getCityId());
        addressReq.setTownshipId(userTargetInfo.getTownshipId());

        addressReq.setFloor(userTargetInfo.getLayFloor());
        addressReq.setStairType(userTargetInfo.getStairType());

        addressReq.setLongitude(userTargetInfo.getLongitude());
        addressReq.setLatitude(userTargetInfo.getLatitude());

        addressReq.setRelaPhone(userTargetInfo.getMobile());
        String relaName="";
        if(StrUtil.isNotBlank(userTargetInfo.getUserName())){
            relaName=userTargetInfo.getUserName();
        }else if(StrUtil.isNotBlank(userTargetInfo.getNickName())){
            relaName=Base64.decodeStr(userTargetInfo.getNickName());
        }else {
            relaName="无";
        }
        addressReq.setRelaName(relaName);

        addressService.addressAdd(addressReq);
    }



    @Scheduled(cron = "${cron.loginTime}")
    @Async
    public void syncLoginTime() {
        log.trace("********定时同步登录时间任务开始【凌晨执行】*********");
        if(!SpringUtil.isCloud()) {
            Map<String, String> stringStringMap = redisUtil.hgetAll(Constants.REDIS_USER_KEY + "loginInfo");
            if (!CollectionUtils.isEmpty(stringStringMap)) {
                for (String s : stringStringMap.keySet()) {
                    String s1 = stringStringMap.get(s);
                    Dict dict = JSONUtil.parseObj(s1).toBean(Dict.class);
                    String time = dict.getStr("time");
                    String ip = dict.getStr("ip");
                    //登录日志
                    UserLoginInfo userLoginInfo = new UserLoginInfo();
                    userLoginInfo.setLoginTime(time);
                    userLoginInfo.setIpAddress(ip);
                    userLoginInfo.setUserId(s);
                    UserInfo userInfo = userMapper.selectByPrimaryKey(s);
                    if (userInfo != null && userInfo.getDelFlag() == Constants.DEL_NOT_FLAG) {
                        userLoginInfo.setMobilePhone(userInfo.getMobilePhone());
                        userLoginInfo.setUserType(CommonEnum.普通用户.getValue());
                    } else {
                        OtherUserInfo byId = otherUserService.findById(s);
                        if (byId != null) {
                            userLoginInfo.setMobilePhone(byId.getMobilePhone());
                            userLoginInfo.setUserType(byId.getUserType());
                        }
                    }
                    userLoginInfoMapper.insertSelective(userLoginInfo);

                    //删除用户缓存
                    redisUtil.hdel(Constants.REDIS_USER_KEY + "loginInfo", s);

                }
            }
        }
        log.trace("********定时同步登录时间任务结束*********");
    }


}