package com.template.services.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.template.mapper.SmartUserMapper;
import com.template.model.dto.WarningUserDto;
import com.template.model.enumModel.eIdentityStatu;
import com.template.model.pojo.SmartUser;
import com.template.model.pojo.SmartWarning;
import com.template.model.result.PageUtils;
import com.template.model.vo.*;
import com.template.services.SmartUserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.List;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author ceshi
 * @since 2023-12-04
 */
@Service
public class SmartUserServiceImpl extends ServiceImpl<SmartUserMapper, SmartUser> implements SmartUserService {
    @Autowired
    private SmartUserMapper smartUserMapper;

    @Override
    public int insertSmartUser(SmartUser sa) {
        int result = smartUserMapper.insert(sa);
        return sa.getId();
    }

    @Override
    public int updateSmartUser(SmartUser sa) {
        int result = smartUserMapper.updateById(sa);
        return result;
    }

    @Override
    public PageUtils<SmartUser> queryPageSmartUsers(int currentPage, int pageCount, List<Integer> departmentIds) {
        Page<SmartUser> page = new Page<>(currentPage, pageCount);
//        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper<>();
//        queryWrapper.eq(departmentId > 0, "department_id", departmentId);
        IPage<SmartUser> result = smartUserMapper.selectPage(page, null);
        return new PageUtils<>(result);
    }

    @Override
    public PageUtils<UserVo> querySmartUserPages(int currentPage, int pageCount, List<Integer> departmentIds, String name) {
        Page<UserVo> page = new Page<>();
        page.setCurrent(currentPage);
        page.setSize(pageCount);
        IPage<UserVo> result = smartUserMapper.querySmartUserPages(page, departmentIds, name);
        return new PageUtils(result);
    }

    @Override
    public PageUtils<GradeVo> querySmartSecordPage(int currentPage, int pageCount, String name, Integer userId) {
        Page<GradeVo> page = new Page<>();
        page.setCurrent(currentPage);
        page.setSize(pageCount);
        IPage<GradeVo> result = smartUserMapper.querySmartSecordPage(page, name, userId);
        return new PageUtils(result);
    }

    @Override
    public List<SmartUser> querySmartUsers(List<Integer> departmentIds, String name) {
        List<SmartUser> result = smartUserMapper.querySmartUsers(departmentIds, name);
        return result;
    }


    @Override
    public List<SmartUser> getSmartUserByIds(List<Integer> ids) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.in("id", ids);
        queryWrapper.eq("is_cancel", 0);
        List<SmartUser> result = smartUserMapper.selectList(queryWrapper);
        return result;
    }

    @Override
    public List<SmartUser> getSmartUserIds(List<String> ids) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.in("id", ids);
        queryWrapper.eq("is_cancel", 0);
        List<SmartUser> result = smartUserMapper.selectList(queryWrapper);
        return result;
    }

    @Override
    public int getSmartUserCountByIds(List<Integer> ids) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.in("id", ids);
        queryWrapper.eq("is_cancel", 0);

        int result = smartUserMapper.selectCount(queryWrapper);
        return result;
    }

    @Override
    public boolean updateUserBatchById(List<SmartUser> users) {
        boolean result = this.updateBatchById(users);
        return result;
    }

    @Override
    public Integer querySmartUserByCardNo(String cardNo) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("card_no", cardNo);
        queryWrapper.eq("is_cancel", 0);

        int existCount = smartUserMapper.selectCount(queryWrapper);
        return existCount;
    }

    @Override
    public List<SmartUser> queryStudentBySchoolClass(Integer schoolClass) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("school_class", schoolClass);
        queryWrapper.eq("identity_id", eIdentityStatu.Student.getValue());
        queryWrapper.eq("is_cancel", 0);

        List<SmartUser> result = smartUserMapper.selectList(queryWrapper);
        return result;
    }

    @Override
    public int deleteSmartUserById(int id) {
        int result = smartUserMapper.deleteById(id);
        return result;
    }

    @Override
    public int deleteSmartUserByIds(List<Integer> ids) {
        int result = smartUserMapper.deleteBatchIds(ids);
        return result;
    }

    @Override
    public SmartUser getSmartById(Integer id) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("is_cancel", 0);
        queryWrapper.eq("id", id);
        SmartUser result = smartUserMapper.selectOne(queryWrapper);
        return result;
    }

    @Override
    public List<SmartUser> getSmartUserByxwuids(List<String> xwuids) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.in("xw_student_uid", xwuids);
        queryWrapper.eq("is_cancel", 0);
        List<SmartUser> result = smartUserMapper.selectList(queryWrapper);
        return result;
    }

    @Override
    public List<SmartUser> getListPush() {

        LambdaQueryWrapper<SmartUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SmartUser::getIsCancel, 0)
                .eq(SmartUser::getIsPush, 1);

        List<SmartUser> smartUserList = this.list(wrapper);

        return smartUserList;
    }

    @Override
    public List<SmartUser> getAffiliateList(Integer id) {
        return smartUserMapper.getAffiliateList(id);
    }

    @Override
    public List<AffiliateUserVo> queryAffiliateUserById(Integer id) {
        List<AffiliateUserVo> result = smartUserMapper.queryAffiliateUserById(id);
        return result;
    }

    @Override
    public List<SmartUser> queryDatasByDepartments(List<Integer> departments) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.in("department_id", departments);
        List<SmartUser> users = smartUserMapper.selectList(queryWrapper);
        return users;
    }

    @Override
    public List<SmartUser> queryStudentDatas() {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("is_cancel", 0);
        queryWrapper.eq("identity_id", eIdentityStatu.Student.getValue());
        List<SmartUser> result = smartUserMapper.selectList(queryWrapper);
        return result;
    }

    @Override
    public List<SmartUser> queryStudentDatas(Integer identityId, List<Integer> gradeIds) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("is_cancel", 0);
        queryWrapper.eq("identity_id", eIdentityStatu.Student.getValue());
        queryWrapper.in(gradeIds != null && gradeIds.size() > 0 ,"grade",gradeIds);
        List<SmartUser> result = smartUserMapper.selectList(queryWrapper);
        return result;
    }

    @Override
    public PageUtils<WarningUserDto> warningUserList(int currentPage, int pageCount, String name) {
        Page<UserVo> page = new Page<>();
        page.setCurrent(currentPage);
        page.setSize(pageCount);
        IPage<WarningUserDto> result = smartUserMapper.warningUserList(page, name);
        return new PageUtils(result);
    }

    @Override
    public List<WarningUserDto> warningPushList() {
        return smartUserMapper.warningPushList();
    }

    @Override
    public List<AffiliateParentVo> queryAffiliateParents(Integer userId) {
        return smartUserMapper.queryAffiliateParents(userId);
    }

    @Override
    public SmartUser queryUserInfo(String name, String cardNo, String idCard) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq(StringUtils.hasText(name), "name", name);
        queryWrapper.eq(StringUtils.hasText(cardNo), "card_no", cardNo);
        queryWrapper.eq(StringUtils.hasText(idCard), "id_card", idCard);
        queryWrapper.eq("is_cancel", 0);
        SmartUser result = smartUserMapper.selectOne(queryWrapper);
        return result;
    }

    @Override
    public List<SmartUser> getSmartUserList(List<Integer> ids) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("is_cancel", 0);
        queryWrapper.in("id", ids);
        List<SmartUser> result = smartUserMapper.selectList(queryWrapper);
        return result;
    }

    @Override
    public List<SmartUser> querySmartUserByCardNos(List<String> cardNos) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("is_cancel", 0);
        queryWrapper.in("card_no", cardNos);
        List<SmartUser> result = smartUserMapper.selectList(queryWrapper);
        return result;
    }

    @Override
    public SmartUserVo querySmartUserById(Integer id) {
        SmartUserVo result = smartUserMapper.querySmartUserById(id);

        return result;
    }

    @Override
    public int deleteUserBatch(List<deleteUserVo> list) {
        int result = smartUserMapper.deleteUserBatch(list);
        return result;
    }

    @Override
    public PageUtils<UserDeleteVo> queryUserDeletePage(int currentPage, int pageCount) {
        Page<UserDeleteVo> page = new Page<>();
        page.setCurrent(currentPage);
        page.setSize(pageCount);
        IPage<UserDeleteVo> result = smartUserMapper.queryUserDeletePage(page);
        return new PageUtils(result);

    }

    @Override
    public SmartStudentVo querySmartStudentById(Integer userId) {
        SmartStudentVo result = smartUserMapper.querySmartStudentById(userId);
        return result;
    }

    @Override
    public List<SmartUser> queryStudentsByGrade(List<String> gradeIds) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("identity_id", eIdentityStatu.Student.getValue());
        queryWrapper.in(gradeIds != null && gradeIds.size() > 0, "grade", gradeIds);
        List<SmartUser> result = smartUserMapper.selectList(queryWrapper);
        return result;
    }

    @Override
    public List<SmartUser> queryUsersByClass(Integer schoolClass) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq(schoolClass != null, "school_class", schoolClass);
        queryWrapper.eq("identity_id", eIdentityStatu.Student.getValue());
        List<SmartUser> users = smartUserMapper.selectList(queryWrapper);
        return users;
    }

    @Override
    public List<SmartUser> getListUser() {

        LambdaQueryWrapper<SmartUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SmartUser::getIsCancel, 0);

        List<SmartUser> smartUserList = this.list(wrapper);

        return smartUserList;
    }

    @Override
    public SmartUser getPhoneUser(String phone) {
        LambdaQueryWrapper<SmartUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SmartUser::getPhone, phone)
                .eq(SmartUser::getIdentityId, 1);
        SmartUser smartUser = this.getOne(wrapper);
        return smartUser;
    }

    @Override
    public List<SmartUser> getPhoneUsers(String phone) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("phone", phone);
        List<SmartUser> result = smartUserMapper.selectList(queryWrapper);
        return result;
    }

    @Override
    public List<SmartUserAffiliateVo> getAffiliateUser(String affiliate) {
        return smartUserMapper.getAffiliateUser(affiliate);
    }

    @Override
    public SmartUser getCard(String certificateNumber) {
        LambdaQueryWrapper<SmartUser> wrapper = new LambdaQueryWrapper<>();
        wrapper/*.eq(SmartUser::getIdCard,certificateNumber)
                .or()*/
                .eq(SmartUser::getCardNo, certificateNumber);
        SmartUser one = this.getOne(wrapper);

        return one;
    }

    @Override
    public SmartUser getBsStudentNo(String idNum) {
        LambdaQueryWrapper<SmartUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SmartUser::getBsStudentNo, idNum)
                .or()
                .eq(SmartUser::getBsStaffCode, idNum)
                .or()
                .eq(SmartUser::getIdCard, idNum);
        SmartUser one = this.getOne(wrapper);
        return one;
    }

    @Override
    public List<SmartUser> getChargeTeacher(Integer schoolClass) {
        LambdaQueryWrapper<SmartUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SmartUser::getSchoolClass, schoolClass)
                .eq(SmartUser::getDepartmentId, 137);
        List<SmartUser> list = this.list(wrapper);

        return list;
    }

    @Override
    public List<StudentSelectVo> studentSelect(String keyWord) {
        return smartUserMapper.studentSelect(keyWord);
    }

    @Override
    public List<SmartUser> querySmartParentByIds(List<Integer> studentIds) {
        List<SmartUser> result = smartUserMapper.querySmartParentByIds(studentIds);
        return result;
    }

    @Override
    public int queryStudentCount() {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("identity_id", eIdentityStatu.Student.getValue());
        int result = smartUserMapper.selectCount(queryWrapper);
        return result;
    }

    @Override
    public List<StatisticsCampusVo> getAccessStatisticsCampus(Integer classId, LocalDateTime startTime, LocalDateTime endTime) {
        return smartUserMapper.getAccessStatisticsCampus(classId, startTime, endTime);
    }

    @Override
    public List<StatisticsCampusVo> getAttendanceStatisticsCampus(Integer classId, LocalDateTime startTime, LocalDateTime endTime) {
        return smartUserMapper.getAttendanceStatisticsCampus(classId, startTime, endTime);
    }

    @Override
    public List<StatisticsCampusVo> getFaceDiscernStatisticsCampus(Integer classId, LocalDateTime startTime, LocalDateTime endTime) {
        return smartUserMapper.getFaceDiscernStatisticsCampus(classId, startTime, endTime);
    }

    @Override
    public List<StatisticsCampusVo> getAckStatisticsCampus(Integer classId, LocalDateTime startTime, LocalDateTime endTime) {
        return smartUserMapper.getAckStatisticsCampus(classId, startTime, endTime);
    }

    @Override
    public List<StatisticsCampusVo> getClassStudent(Integer classId) {
        return smartUserMapper.getClassStudent(classId);
    }

    @Override
    public List<SmartUser> queryTeachers() {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("identity_id", eIdentityStatu.Teacher.getValue());
        List<SmartUser> result = smartUserMapper.selectList(queryWrapper);
        return result;
    }

    @Override
    public List<SmartUser> getAddressBook(Integer userId) {
        LambdaQueryWrapper<SmartUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SmartUser::getAffiliate, userId);
        wrapper.eq(SmartUser::getIsCancel, 0);
        List<SmartUser> list = this.list(wrapper);
        return list;
    }

    @Override
    public List<StatisticsCampusManageVo> getAccessStatisticsCampusManage(Integer gradeId, Integer classId, LocalDateTime startTime, LocalDateTime endTime, String keyWord) {
        return smartUserMapper.getAccessStatisticsCampusManage(gradeId, classId, startTime, endTime, keyWord);
    }

    @Override
    public List<StatisticsCampusManageVo> getAttendanceStatisticsCampusManage(Integer gradeId, Integer classId, LocalDateTime startTime, LocalDateTime endTime, String keyWord) {
        return smartUserMapper.getAttendanceStatisticsCampusManage(gradeId, classId, startTime, endTime, keyWord);
    }

    @Override
    public List<StatisticsCampusManageVo> getFaceDiscernStatisticsCampusManage(Integer gradeId, Integer classId, LocalDateTime startTime, LocalDateTime endTime, String keyWord) {
        return smartUserMapper.getFaceDiscernStatisticsCampusManage(gradeId, classId, startTime, endTime, keyWord);
    }

    @Override
    public List<StatisticsCampusManageVo> getAckStatisticsCampusManage(Integer gradeId, Integer classId, LocalDateTime startTime, LocalDateTime endTime, String keyWord) {
        return smartUserMapper.getAckStatisticsCampusManage(gradeId, classId, startTime, endTime, keyWord);
    }

    @Override
    public List<StatisticsCampusManageVo> getClassStudentManage(Integer gradeId, Integer classId, String keyWord) {
        return smartUserMapper.getClassStudentManage(gradeId, classId, keyWord);
    }

    @Override
    public int queryParentByCount(String phone) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("identity_id", eIdentityStatu.Parent.getValue());
        queryWrapper.eq("phone", phone);
        int result = smartUserMapper.selectCount(queryWrapper);
        return result;
    }

    @Override
    public SmartUser queryParentByPhone(String phone) {
        QueryWrapper<SmartUser> queryWrapper = new QueryWrapper();
        queryWrapper.eq("identity_id", eIdentityStatu.Parent.getValue());
        queryWrapper.eq("phone", phone);
        SmartUser result = smartUserMapper.selectOne(queryWrapper);
        return result;
    }

    @Override
    public PageUtils<SmartUserPageVo> getPage(int currentPage, int pageCount, String keyWord, String schoolClass) {
        Page<SmartUserPageVo> page = new Page<>();
        page.setCurrent(currentPage);
        page.setSize(pageCount);
        IPage<SmartUserPageVo> result = smartUserMapper.getPage(page, keyWord, schoolClass);
        return new PageUtils(result);
    }

    @Override
    public List<StatisticsStatement> getUserClassTotal() {
        return smartUserMapper.getUserClassTotal();
    }

    @Override
    public List<StatisticsStatement> getUserAckTotal(LocalDateTime startTime, LocalDateTime endTime) {
        return smartUserMapper.getUserAckTotal(startTime, endTime);
    }

    @Override
    public List<StatisticsStatement> getUserNormalTotal(LocalDateTime startTime, LocalDateTime endTime) {
        return smartUserMapper.getUserNormalTotal(startTime, endTime);
    }


}