package com.example.jz.controller;


import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.baomidou.mybatisplus.core.toolkit.Wrappers;
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.*;
import com.example.jz.service.*;
import com.example.jz.utils.HttpUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
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 javax.annotation.Resource;
import java.io.Serializable;
import java.sql.Array;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/wx")
@Api(tags = "微信小程序接口")
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;
    @Autowired
    PublicityService publicityService;
    @Autowired
    private AnnouncementService announcementService;
    @Autowired
    private PoliceAnnouncementService policeAnnouncementService;

    @GetMapping("/checkIdentity")
    public R checkIdentity(@RequestParam String code, @RequestParam String phoneNumberCode) throws Exception {
        //小程序登录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()));
        if(Objects.isNull(user)){
            return R.ok(2, phone_info.getPurePhoneNumber());
        }else {
            if (user.getRole() == 1){
                return R.ok(1, phone_info.getPurePhoneNumber());
            } else  {
                return R.ok(0, phone_info.getPurePhoneNumber());
            }
        }
    }

//    @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();
//        }
//        User user1 = userDao.selectOne(new QueryWrapper<User>().eq("user_mobile", phone_info.getPurePhoneNumber()));
//        HashMap<String, Object> loginMessage = new HashMap<>();
//        loginMessage.put("id", id);
//        loginMessage.put("token", token);
//        loginMessage.put("role", role);
//        loginMessage.put("time", user1.getUserIdcard());
//        return R.ok(loginMessage);
//    }

    @GetMapping("/login")
    @SneakyThrows
    public R login(@RequestParam String phone) {
        User user = userDao.selectOne(new QueryWrapper<User>().eq("user_mobile", phone));
        String token;
        Integer role;
        Integer id = null;
        if (user == null || user.getId() == null) {
            User newUser = new User();
            newUser.setUserMobile(phone);
            newUser.setUserRegtime(new Date());
            newUser.setOpenid(phone);
            newUser.setStatus(1);
            newUser.setRole(0);
            newUser.setCtime(new Date());
            userService.save(newUser);
            token = tokenJwtManager.createToken(newUser);
            role = 0;
            id = newUser.getId();
        } else {
            user.setUserLasttime(new Date());
            userDao.updateById(user);
            token = tokenJwtManager.createToken(user);
            role = user.getRole();
            id = user.getId();
        }
        User user1 = userDao.selectOne(new QueryWrapper<User>().eq("user_mobile", phone));
        HashMap<String, Object> loginMessage = new HashMap<>();
        loginMessage.put("id", id);
        loginMessage.put("token", token);
        loginMessage.put("role", role);
        loginMessage.put("time", user1.getUserIdcard());
        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) {
        List<Report> reports = reportService.list(new QueryWrapper<Report>().eq("user_id", id));
        List<ReportVXVO> res = reports.stream()
                .map(item -> {
                    ReportVXVO res1 = new ReportVXVO();
                    BeanUtils.copyProperties(item, res1);
                    if (!Objects.isNull(causeService.getById(item.getCauseId()))){
                        res1.setReportDescription(causeService.getById(item.getCauseId()).getName());
                    }
                    return res1;
                }).collect(Collectors.toList());
        return R.ok(res);
    }

    @PostMapping("/user/addReport")
    public R addReport(@RequestBody ReportVXVO reportVXVO) {
        User user = userService.getOne(new QueryWrapper<User>().eq("id", reportVXVO.getUserId()));
        user.setRealName(reportVXVO.getRealName());
        user.setSex(reportVXVO.getSex());
        user.setUserIdcard(reportVXVO.getUserIdCard());
        user.setLocation(reportVXVO.getLocation());
        user.setWorkingLocation(reportVXVO.getWorkingLocation());

        userService.update(user, new LambdaQueryWrapper<User>().eq(User::getId, user.getId()));
        Report report = new Report();
        BeanUtils.copyProperties(reportVXVO, report);
        report.setAmountInvolved(reportVXVO.getAmountInvolved());
        report.setPic(user.getPic());
        report.setIsInGroup(0);
        report.setCtime(new Date());
        report.setStatus(0);
        report.setReportMethod("扫码报案");
        return R.ok(reportService.save(report));
    }

    @PostMapping("/user/policeAddReport")
    public R policeAddReport(@RequestBody ReportVXVO reportVXVO) {
        User one = userService.getOne(Wrappers.<User>lambdaQuery().eq(User::getUserMobile, reportVXVO.getPhone()));
        if (Objects.nonNull(one)){
             return R.ok("该手机号已被注册");
        }

        User user = new User();

        user.setUserMobile(reportVXVO.getPhone());
        user.setRealName(reportVXVO.getRealName());
        user.setSex(reportVXVO.getSex());
        user.setUserIdcard(reportVXVO.getUserIdCard());
        user.setLocation(reportVXVO.getLocation());
        user.setWorkingLocation(reportVXVO.getWorkingLocation());
        user.setCtime(new Date());
        userService.save(user);

        Report report = new Report();
        BeanUtils.copyProperties(reportVXVO, report);
        report.setAmountInvolved(reportVXVO.getAmountInvolved());
        report.setUserId(user.getId());
        report.setPic(user.getPic());
        report.setIsInGroup(0);
        report.setCtime(new Date());
        report.setStatus(0);
        report.setReportMethod("扫码报案");
        return R.ok(reportService.save(report));
    }

    @PutMapping ("/user/addReport")
    public R addReport1(@RequestBody ReportVXVO reportVXVO) {
        User user = userService.getOne(new QueryWrapper<User>().eq("id", reportVXVO.getUserId()));
        user.setRealName(reportVXVO.getRealName());
        user.setSex(reportVXVO.getSex());
        user.setUserIdcard(reportVXVO.getUserIdCard());
        user.setLocation(reportVXVO.getLocation());
        user.setWorkingLocation(reportVXVO.getWorkingLocation());

        userService.update(user, new LambdaQueryWrapper<User>().eq(User::getId, user.getId()));
        Report report = new Report();
        BeanUtils.copyProperties(reportVXVO, report);
        report.setAmountInvolved(reportVXVO.getAmountInvolved());
        report.setPic(user.getPic());
        report.setIsInGroup(0);
        report.setCtime(new Date());
        report.setStatus(0);
        report.setReportMethod("扫码报案");

        reportService.update(report, new LambdaQueryWrapper<Report>().eq(Report::getId, report.getId()));
        return R.ok("修改成功");
    }

    @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<Group> groupUsers = groupService.list(new QueryWrapper<Group>().eq("user_id", id));
        if (!groupUsers.isEmpty()) {
            groupUsers.forEach(item -> {
                HashMap<String, Object> groupMap = new HashMap<>();
                List<Message> message = messageService.list(new QueryWrapper<Message>().eq("group_id", item.getId()).orderByDesc("ctime"));
                groupMap.put("groupName", item.getGroupName());
                getMessage(groupMap, message);
                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("/isExist")
    public R isExist(@RequestParam String phone){
        User one = userService.getOne(new LambdaQueryWrapper<User>().eq(User::getUserMobile, phone));
        if(Objects.isNull(one)){
            return R.ok(false, "该手机号没有被注册");
        }else {
            return R.ok(true, "该手机号已被注册");
        }
    }

    /**
     *  显示用户信息
     */
    @GetMapping("/getGroupUserInfo")
    public R getGroupUserInfo(@RequestParam Integer id){
        User one = userService.getOne(new LambdaQueryWrapper<User>().eq(User::getId, id));
        MessageUserInfoVO messageUserInfoVO = new MessageUserInfoVO();
        BeanUtils.copyProperties(messageUserInfoVO, one);
        return R.ok(messageUserInfoVO);
    }

    private void getMessage(HashMap<String, Object> groupMap, List<Message> message) {
        if (!message.isEmpty()) {
            groupMap.put("message", message.get(0).getText());
            if (message.get(0).getUserId() == null) {
                groupMap.put("name", userDao.selectOne(new QueryWrapper<User>().eq("id", message.get(0).getCopId())).getRealName());
            } else {
                groupMap.put("name", message.get(0).getReportName());
            }
            groupMap.put("time", message.get(0).getCtime());
        }
    }


    @GetMapping("/user/group/list")
    public R getUserMessage(@RequestParam Integer id, @RequestParam String newDate, @RequestParam String lastDate) {
        ArrayList<Map<String, Object>> list = new ArrayList<>();
        reportService.listGroup(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"));
                                getMessage(groupMap, message);
                                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());
                    messageMap.put("messageId", item.getId());
                    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()));
                        if (Objects.isNull(user)) {
                            return;
                        }
                        messageMap.put("id", user.getId());
                        messageMap.put("name", item.getReportName());
                        messageMap.put("mobile", user.getUserMobile());
                        messageMap.put("idcard", user.getUserIdcard());
                        messageMap.put("sex", user.getSex());
                        messageMap.put("pic", user.getPic());
                        messageMap.put("role", 0);
                        messageMap.put("remark", user.getUserMemo());
                    } else {
                        messageMap.put("id", item.getCopId());
                        User user = userService.getOne(new QueryWrapper<User>().eq("id", item.getCopId()));
                        if (Objects.isNull(user)) {
                            return;
                        }
                        messageMap.put("name", user.getRealName());
                        messageMap.put("mobile", user.getUserMobile());
                        messageMap.put("sex", user.getSex());
                        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) {
        if (StringUtils.isBlank(msg)) {
            return R.failed("msg is blank");
        }
        GroupUser one = groupUserService.getOne(new LambdaQueryWrapper<GroupUser>().eq(GroupUser::getUserId, id).eq(GroupUser::getGroupId, groupId));
        if (one.getBanSpeech() == 1){
            return R.failed("该用户已经被禁言");
        }
        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));
    }

    @GetMapping("/group/member/detail")
    public R getMemberDetail(@RequestParam Integer id) {
        Report report = reportService.getOne(new LambdaQueryWrapper<Report>().eq(Report::getId, id));
        ReportVo reportVo = new ReportVo();
        BeanUtils.copyProperties(report, reportVo);
        User user = userDao.selectOne(new LambdaQueryWrapper<User>().eq(User::getId, report.getUserId()));
        reportVo.setReporterName(user.getRealName());
        reportVo.setMobile(user.getUserMobile());
        reportVo.setIdcard(user.getUserIdcard());
        return R.ok(reportVo);
    }

    /**
     *
     * @param id
     * @return
     */
    @GetMapping("/manager/report")
    public R queryReport(@RequestParam Integer id) {
        List<Integer> collect = causeService.list(Wrappers.<Cause>lambdaQuery().eq(Cause::getUserId, id)).stream().map(cause -> cause.getId()).collect(Collectors.toList());
        R<List<ReportVo>> ok = R.ok(reportService.list(new LambdaQueryWrapper<Report>().eq(Report::getStatus, 0).in(Report::getCauseId, collect))
                .stream()
                .map(item -> {
                    ReportVo reportVo = new ReportVo();
                    BeanUtils.copyProperties(item, reportVo);
                    User user = userDao.selectOne(new LambdaQueryWrapper<User>().eq(User::getId, item.getUserId()));
                    Cause one = causeService.getOne(new LambdaQueryWrapper<Cause>().eq(Cause::getId, item.getCauseId()));
                    reportVo.setReportDescription(one.getName());
                    reportVo.setReporterName(user.getRealName());
                    reportVo.setMobile(user.getUserMobile());
                    reportVo.setIdcard(user.getUserIdcard());
                    return reportVo;
                })
                .collect(Collectors.toList()));
        return ok;
    }

    @GetMapping("/publicity")
    public R queryPublicity(@RequestParam(required = false) Integer size) {
        List<Publicity> publicityList = publicityService.list(new LambdaQueryWrapper<Publicity>().eq(Publicity::getStatus, 1));
        if (size != null) {
            return R.ok(publicityList.stream().limit(size));
        }
        return R.ok(publicityList);
    }

    @GetMapping("/publicity/{id}")
    @ApiOperation("通过主键查询单条数据")
    public R<Publicity> selectOne(@PathVariable Serializable id) {
        return R.ok(publicityService.getById(id));
    }

    @ApiOperation(httpMethod = "POST", value = "群公告添加")
    @PostMapping("/announcement/add")
    public R insert(@RequestParam(value = "groupId") Integer groupId, @RequestParam String announcement) {
        Announcement announcement1 = new Announcement();
        announcement1.setText(announcement);
        announcement1.setStatus(1);
        return R.ok(announcementService.vxAdd(groupId, announcement1));
    }

    @ApiOperation(httpMethod = "DELETE", value = "群公告删除")
    @DeleteMapping("/announcement/delete")
    public R delete(@RequestParam(value = "id") Integer id) {
        announcementService.removeById(id);
        return R.ok();
    }

    @ApiOperation(httpMethod = "GET", value = "查看群公告")
    @GetMapping("/getAnnouncements")
    public R getAnnouncements(@RequestParam(value = "groupId") Integer groupId) {
        return R.ok(announcementService.getAnnouncements(groupId));
    }

    @GetMapping("policeAnnouncement/list")
    @ApiOperation(httpMethod = "GET", value = "警方公告")
    public R getPoliceAnnouncement(){
        List<PoliceAnnouncement> list = policeAnnouncementService.list(Wrappers.<PoliceAnnouncement>lambdaQuery().eq(PoliceAnnouncement::getStatus, 1).orderByDesc(PoliceAnnouncement::getCtime));
        return R.ok(list);
    }
}