package com.example.jz.controller;


import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.example.jz.auth.TokenJwtManager;
import com.example.jz.dao.UserDao;
import com.example.jz.modle.R;
import com.example.jz.modle.entity.*;
import com.example.jz.modle.vo.CauseVo;
import com.example.jz.modle.vo.MemberVo;
import com.example.jz.service.*;
import com.example.jz.utils.HttpUtil;
import lombok.SneakyThrows;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.*;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/wx")
public class WxAppController {

    private final String wxApp_userCode_verify_url = "https://api.weixin.qq.com/sns/jscode2session";

    private final String wxApp_phoneNumber_verify_url = "https://api.weixin.qq.com/wxa/business/getuserphonenumber";

    private final String wxApp_accessToken_verify_url = "https://api.weixin.qq.com/cgi-bin/token";

    @Value("${wx.appid}")
    private  String appid;

    @Value("${wx.secret}")
    private String secret;

    private final String js_code = "";

    private final String grant_type = "authorization_code";

    @Autowired
    UserDao userDao;
    @Autowired
    UserService userService;
    @Autowired
    TokenJwtManager tokenJwtManager;
    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    ReportService reportService;
    @Autowired
    CauseService causeService;
    @Autowired
    GroupService groupService;
    @Autowired
    MessageService messageService;
    @Autowired
    GroupUserService groupUserService;

    @GetMapping("/login")
    @SneakyThrows
    public R login(@RequestParam String code, @RequestParam String phoneNumberCode) {
        //小程序登录openid
        Map<String, Object> pathUrl = new HashMap<>();
        pathUrl.put("appid", appid);
        pathUrl.put("secret", secret);
        pathUrl.put("js_code", code);
        pathUrl.put("grant_type", grant_type);
        JSONObject result = JSONUtil.parseObj(HttpUtil.doGet(wxApp_userCode_verify_url, pathUrl));

        //手机号码的access token
        Map<String, Object> accessToken = new HashMap<>();
        accessToken.put("appid", appid);
        accessToken.put("secret", secret);
        accessToken.put("grant_type", "client_credential");
        JSONObject accessTokenResult = JSONUtil.parseObj(HttpUtil.doGet(wxApp_accessToken_verify_url, accessToken));

        //电话号码
        String url = wxApp_phoneNumber_verify_url + "?access_token=" + accessTokenResult.get("access_token");
        Map<String, Object> phoneNumber = new HashMap<>();
        phoneNumber.put("code", phoneNumberCode);

        HttpHeaders headers = new HttpHeaders();
        HttpEntity httpEntity = new HttpEntity<>(phoneNumber, headers);
        System.out.println(httpEntity);
        ResponseEntity response = restTemplate.postForEntity(url, httpEntity, Object.class);
        response.getBody();
        JSONObject entries = JSONUtil.parseObj(response.getBody());
        PhoneInFo phone_info = entries.get("phone_info", PhoneInFo.class);
        User user = userDao.selectOne(new QueryWrapper<User>().eq("user_mobile", phone_info.getPurePhoneNumber()));
        String token;
        Integer role;
        Integer id = null;
        if (user == null || user.getId() == null) {
            User newUser = new User();
            newUser.setUserMobile(phone_info.getPurePhoneNumber());
            newUser.setUserRegtime(new Date());
            newUser.setOpenid(result.get("openid").toString());
            newUser.setStatus(1);
            newUser.setRole(0);
            newUser.setCtime(new Date());
            userService.save(newUser);
            token = tokenJwtManager.createToken(newUser);
            role = 0;
            id = newUser.getId();
        } else {
            user.setOpenid(result.get("openid").toString());
            user.setUserLasttime(new Date());
            userDao.updateById(user);
            token = tokenJwtManager.createToken(user);
            role = user.getRole();
            id = user.getId();
        }
        HashMap<String, Object> loginMessage = new HashMap<>();
        loginMessage.put("id", id);
        loginMessage.put("token", token);
        loginMessage.put("role", role);
        return R.ok(loginMessage);
    }

    @GetMapping("/manager/myself")
    public R getReport(Integer id) {
        HashMap<String, Object> myselfMessage = new HashMap<>();
        User user = userService.getOne(new QueryWrapper<User>().eq("id", id));
        int causeNum = causeService.count(new QueryWrapper<Cause>().eq("user_id", id));
        Integer reporterNum = causeService.list(new QueryWrapper<Cause>().eq("user_id", id)).stream().mapToInt(item -> reportService.count(new QueryWrapper<Report>().eq("cause_id", item.getId()))).sum();
        myselfMessage.put("name", user.getRealName());
        myselfMessage.put("phoneNum", user.getUserMobile());
        myselfMessage.put("causeNum", causeNum);
        myselfMessage.put("reporterNum", reporterNum);
        return R.ok(myselfMessage);
    }

    @GetMapping("/user/myself")
    public R getMyself(Integer id) {
        return R.ok(userService.getOne(new QueryWrapper<User>().eq("id", id)));
    }

    @GetMapping("/user/cause")
    public R getCause(Integer id) {
        return R.ok(reportService.list(new QueryWrapper<Report>().eq("user_id", id)));
    }

    @PostMapping("/user/addReport")
    public R addReport(@RequestBody Report report) {
        User user = userService.getOne(new QueryWrapper<User>().eq("id", report.getUserId()));
        report.setPic(user.getPic());
        report.setIsInGroup(0);
        report.setCtime(new Date());
        report.setStatus(0);
        report.setReportMethod("现场录入");
        return R.ok(reportService.save(report));
    }

    @PostMapping("/user/add")
    public R addUser(@RequestBody User user) {
        user.setUserLasttime(new Date());
        return R.ok(userService.updateById(user));
    }

    @GetMapping("/manager/group/list")
    public R getMessage(@RequestParam Integer id, @RequestParam String newDate, @RequestParam String lastDate) {
        ArrayList<Map<String, Object>> list = new ArrayList<>();
//        List<GroupUser> groupUsers = groupUserService.list(new QueryWrapper<GroupUser>().eq("user_id", id));
        List<Group> groupUsers = groupService.list(new QueryWrapper<Group>().eq("user_id", id));
        if (groupUsers != null && groupUsers.size() != 0) {
            groupUsers.forEach(item -> {
                HashMap<String, Object> groupMap = new HashMap<>();
                List<Message> message = messageService.list(new QueryWrapper<Message>().eq("group_id", item.getId()).isNotNull("user_id").orderByDesc("ctime"));
                groupMap.put("groupName", item.getGroupName());
                if (message != null && message.size() != 0) {
                    groupMap.put("message", message.get(0).getText());
                    groupMap.put("name", message.get(0).getReportName());
                    groupMap.put("time", message.get(0).getCtime());
                }
                if (StringUtils.isNotBlank(lastDate)) {
                    int count = messageService.count(new QueryWrapper<Message>().eq("group_id", item.getId()).between("ctime", lastDate, newDate));
                    groupMap.put("count", count);
                }
                groupMap.put("id", item.getId());
                list.add(groupMap);
            });
        }
        return R.ok(list);
    }


    @GetMapping("/user/group/list")
    public R getUserMessage(@RequestParam Integer id, @RequestParam String newDate, @RequestParam String lastDate) {
        ArrayList<Map<String, Object>> list = new ArrayList<>();
        reportService.list((new QueryWrapper<Report>().eq("user_id", id)))
                .forEach(item ->
                        {
                            GroupUser groupUser = groupUserService.getOne(new QueryWrapper<GroupUser>().eq("user_id", item.getId()));
                            if (groupUser != null) {
                                HashMap<String, Object> groupMap = new HashMap<>();
                                List<Message> message = messageService.list(new QueryWrapper<Message>().eq("group_id", groupUser.getGroupId()).orderByDesc("ctime"));
                                if (message != null && message.size() != 0) {
                                    groupMap.put("message", message.get(0).getText());
                                    groupMap.put("time", message.get(0).getCtime());
                                }
                                Group group = groupService.getOne(new QueryWrapper<Group>().eq("id", groupUser.getGroupId()));
                                groupMap.put("groupName", group.getGroupName());
                                groupMap.put("id", group.getId());
                                groupMap.put("ban", groupUser.getBanSpeech());
                                groupMap.put("reportId", groupUser.getUserId());
                                if (StringUtils.isNotBlank(lastDate)) {
                                    int count = messageService.count(new QueryWrapper<Message>().eq("group_id", groupUser.getGroupId()).between("ctime", lastDate, newDate));
                                    groupMap.put("count", count);
                                }
                                list.add(groupMap);
                            }
                        }
                );

        return R.ok(list);
    }

    @GetMapping("/message")
    public R getMessage(@RequestParam Integer groupId) {
        ArrayList<HashMap<String, Object>> message = new ArrayList<>();
        messageService.list(new QueryWrapper<Message>().eq("group_id", groupId).orderByAsc("ctime")).stream()
                .forEach(item -> {
                    HashMap<String, Object> messageMap = new HashMap<>();
                    messageMap.put("text", item.getText());
                    messageMap.put("time", item.getCtime());
                    if (item.getUserId() != null) {
                        Report report = reportService.getOne(new QueryWrapper<Report>().eq("id", item.getUserId()));
                        User user = userService.getOne(new QueryWrapper<User>().eq("id", report.getUserId()));
                        messageMap.put("id", user.getId());
                        messageMap.put("name", item.getReportName());
                        messageMap.put("mobile", user.getUserMobile());
                        messageMap.put("pic", user.getPic());
                        messageMap.put("role", 0);
                    } else {
                        messageMap.put("id", item.getCopId());
                        User user = userService.getOne(new QueryWrapper<User>().eq("id", item.getCopId()));
                        messageMap.put("name", user.getRealName());
                        messageMap.put("mobile", user.getUserMobile());
                        messageMap.put("role", 1);
                    }
                    message.add(messageMap);
                });
        return R.ok(message);
    }

    @GetMapping("/group/cause")
    public R getGroupCause(@RequestParam Integer id) {
        Integer causeId = groupService.getOne(new QueryWrapper<Group>().eq("id", id)).getCauseId();
        Cause cause = causeService.getOne(new QueryWrapper<Cause>().eq("id", causeId));
        CauseVo causeVo = new CauseVo();
        BeanUtils.copyProperties(cause, causeVo);
        User user = userService.getOne(new QueryWrapper<User>().eq("id", cause.getUserId()));
        causeVo.setUserName(user.getRealName());
        causeVo.setMobile(user.getUserMobile());
        causeVo.setReportNumber(reportService.count(new QueryWrapper<Report>().eq("cause_id", causeId)));
        return R.ok(causeVo);
    }

    @GetMapping("/group/member")
    public R getGroupMember(@RequestParam Integer id) {
        Map<String, Object> map = new HashMap<>();
        List<GroupUser> groupUserList = groupUserService.list(new QueryWrapper<GroupUser>().eq("group_id", id));
        List<MemberVo> memberVoList = groupUserList.stream()
                .map(item -> {
                    Report report = reportService.getOne(new QueryWrapper<Report>().eq("id", item.getUserId()));
                    User user = userService.getOne(new QueryWrapper<User>().eq("id", report.getUserId()));
                    MemberVo memberVo = new MemberVo();
                    memberVo.setRealName(user.getRealName());
                    memberVo.setPic(user.getPic());
                    memberVo.setId(item.getUserId());
                    memberVo.setBanSpeech(item.getBanSpeech());
                    return memberVo;
                }).collect(Collectors.toList());
        List<Group> groupList = groupService.list(new QueryWrapper<Group>().eq("id", id));
        List<MemberVo> managerMemberVoList = groupList.stream().map(item -> {
                    User user = userService.getOne(new QueryWrapper<User>().eq("id", item.getUserId()));
                    MemberVo memberVo = new MemberVo();
                    memberVo.setRealName(user.getRealName());
                    memberVo.setPic(user.getPic());
                    memberVo.setId(item.getUserId());
                    return memberVo;
                }
        ).collect(Collectors.toList());
        map.put("managerMemberList", managerMemberVoList);
        map.put("managerMemberCount", managerMemberVoList.size());
        map.put("memberList", memberVoList);
        map.put("memberCount", memberVoList.size());
        return R.ok(map);
    }

    @GetMapping("/group/member/find")
    public R getGroupMemberByName(@RequestParam(required = false) String name, @RequestParam Integer id) {
        Map<String, Object> map = new HashMap<>();
        List<GroupUser> groupUserList = groupUserService.list(new QueryWrapper<GroupUser>().eq("group_id", id));
        List<MemberVo> memberVoList = groupUserList.stream()
                .filter(item ->
                        StringUtils
                                .matches(userService.getOne(new QueryWrapper<User>()
                                        .eq("id", reportService.getOne(new QueryWrapper<Report>()
                                                .eq("id", item.getUserId())).getUserId())).getRealName(), name))
                .map(item -> {
                    Report report = reportService.getOne(new QueryWrapper<Report>().eq("id", item.getUserId()));
                    User user = userService.getOne(new QueryWrapper<User>().eq("id", report.getUserId()));
                    MemberVo memberVo = new MemberVo();
                    memberVo.setRealName(user.getRealName());
                    memberVo.setPic(user.getPic());
                    memberVo.setId(item.getUserId());
                    memberVo.setBanSpeech(item.getBanSpeech());
                    return memberVo;
                }).collect(Collectors.toList());
        map.put("memberList", memberVoList);
        map.put("memberCount", memberVoList.size());
        return R.ok(map);
    }

    @GetMapping("/group/member/banSpeech")
    public R banSpeech(@RequestParam Integer id, @RequestParam Integer groupId) {
        return R.ok(groupUserService.update(new UpdateWrapper<GroupUser>().set("ban_speech", 1).eq("user_id", id).eq("group_id", groupId)));
    }

    @GetMapping("/group/member/allBanSpeech")
    public R allBanSpeech(@RequestParam Integer id) {
        return R.ok(groupUserService.update(new UpdateWrapper<GroupUser>().set("ban_speech", 1).eq("group_id", id)));
    }

    @GetMapping("/group/member/allowSpeech")
    public R allowSpeech(@RequestParam Integer id, @RequestParam Integer groupId) {
        return R.ok(groupUserService.update(new UpdateWrapper<GroupUser>().set("ban_speech", 0).eq("user_id", id).eq("group_id", groupId)));
    }

    @GetMapping("/group/member/allAllowSpeech")
    public R allAllowSpeech(@RequestParam Integer id) {
        return R.ok(groupUserService.update(new UpdateWrapper<GroupUser>().set("ban_speech", 0).eq("group_id", id)));
    }

    @GetMapping("/group/records/keyword")
    public R getRecords(@RequestParam String keyWord, @RequestParam Integer groupId) {
        return R.ok(messageService.list(new QueryWrapper<Message>().eq("group_id", groupId).like(StringUtils.isNotBlank(keyWord), "text", keyWord).isNotNull("user_id"))
                .stream().map(item -> {
                    Report report = reportService.getOne(new QueryWrapper<Report>().eq("id", item.getUserId()));
                    String pic = report.getPic();
                    if (StringUtils.isBlank(pic)) {
                        pic = userService.getOne(new QueryWrapper<User>().eq("id", report.getUserId())).getPic();
                    }
                    MemberVo memberVo = new MemberVo();
                    memberVo.setCtime(item.getCtime());
                    memberVo.setText(item.getText());
                    memberVo.setPic(pic);
                    memberVo.setRealName(item.getReportName());
                    return memberVo;
                }).collect(Collectors.toList()));
    }

    @GetMapping("/group/records/member")
    public R getRecords(@RequestParam Integer id, @RequestParam Integer groupId) {
        return R.ok(messageService.list(new QueryWrapper<Message>().eq("group_id", groupId).eq("user_id", id))
                .stream().map(item -> {
                    Report report = reportService.getOne(new QueryWrapper<Report>().eq("id", item.getUserId()));
                    String pic = report.getPic();
                    if (StringUtils.isBlank(pic)) {
                        pic = userService.getOne(new QueryWrapper<User>().eq("id", report.getUserId())).getPic();
                    }
                    MemberVo memberVo = new MemberVo();
                    memberVo.setCtime(item.getCtime());
                    memberVo.setText(item.getText());
                    memberVo.setPic(pic);
                    memberVo.setRealName(item.getReportName());
                    return memberVo;
                }).collect(Collectors.toList()));
    }

    @GetMapping("/group/manager/sendMsg")
    public R sendMsg(@RequestParam Integer id, @RequestParam Integer groupId, @RequestParam String msg) {
        Message message = new Message();
        message.setCopId(id);
        message.setText(msg);
        message.setCtime(new Date());
        message.setGroupId(groupId);
        return R.ok(messageService.save(message));
    }

    @GetMapping("/group/user/sendMsg")
    public R sendUserMsg(@RequestParam Integer id, @RequestParam Integer groupId, @RequestParam String msg) {
        Message message = new Message();
        message.setUserId(id);
        message.setText(msg);
        message.setCtime(new Date());
        message.setGroupId(groupId);
        message.setReportName(userService.getOne(new QueryWrapper<User>().eq("id", reportService.getOne(new QueryWrapper<Report>().eq("id", id)).getUserId())).getRealName());
        return R.ok(messageService.save(message));
    }
}