package com.uas.sso.service.impl;

import com.uas.sso.AccountConfig;
import com.uas.sso.support.SystemSession;
import com.uas.sso.util.StringUtil;
import org.springframework.data.domain.Page;
import com.uas.sso.core.Status;
import com.uas.sso.dao.ApplyUserSpaceDao;
import com.uas.sso.dao.UserDao;
import com.uas.sso.dao.UserspaceDao;
import com.uas.sso.entity.*;
import com.uas.sso.exception.VisibleError;
import com.uas.sso.service.AppService;
import com.uas.sso.service.ApplyUserSpaceService;
import com.uas.sso.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.persistence.criteria.*;
import java.sql.Timestamp;
import java.util.*;


/**
 * @author wangmh
 * @create 2018-01-12 16:19
 * @desc
 **/
@Service
public class ApplyUserSpaceServiceImpl implements ApplyUserSpaceService {

    @Autowired
    private ApplyUserSpaceDao applyUserSpaceDao;

    @Autowired
    private UserDao userDao;

    @Autowired
    private UserspaceDao userspaceDao;

    @Autowired
    private UserService userService;

    @Autowired
    private AppService appService;

    @Override
    public void applyBindUserSpace(Long userUU, Long spaceUU) {
        // 找到用户信息
        User user = userDao.findOne(userUU);
        if (user == null) {
            throw new VisibleError("手机号未注册");
        }

        // 找到企业信息
        Userspace userspace = userspaceDao.findOne(spaceUU);
        if (userspace == null) {
            throw new VisibleError("该企业未注册");
        }

        // 判断用户是否在该企业
        for (Userspace us : user.getUserSpaces()) {
            if (us.getSpaceUU().equals(userspace.getSpaceUU())) {
                throw new VisibleError("你已在该企业");
            }
        }

        // 判断是否已申请
        List<ApplyUserSpace> applyUserSpaces = applyUserSpaceDao.findByUserUUAndSpaceUUAndStatus(user.getUserUU(), userspace.getSpaceUU(), Status.UNAUDIT.getCode());
        if (!CollectionUtils.isEmpty(applyUserSpaces)) {
            throw new VisibleError("你已申请该企业，请耐心等待管理员审核");
        }

        // 添加绑定状态
        ApplyUserSpace applyUserSpace = new ApplyUserSpace(user, userspace);
        applyUserSpaceDao.save(applyUserSpace);
    }

    @Override
    public Page<ApplyUserSpace> findApplyAll(Integer pageNumber, Integer pageSize, final Long spaceUU) {
        Pageable pageable = PageInfo.pageRequest(new PageRequest(pageNumber, pageSize));
        Page<ApplyUserSpace> page = applyUserSpaceDao.findAll(new Specification<ApplyUserSpace>() {
            @Override
            public Predicate toPredicate(Root<ApplyUserSpace> root,
                                         CriteriaQuery<?> query, CriteriaBuilder cb) {
                List<Predicate> list = new ArrayList<>();
                list.add(cb.equal(root.get("spaceUU").as(Long.class), spaceUU));

                Predicate[] predicates = new Predicate[list.size()];
                predicates = list.toArray(predicates);
                return cb.and(predicates);
            }
        }, pageable);
        return new PageInfo<>(page.getContent(), pageable, page.getTotalElements());
    }

    @Override
    public Map<String, Integer> applyCount(Long spaceUU) {
        List<Map<String, Object>> list = applyUserSpaceDao.applyCountByStatus(spaceUU);
        Map<String, Integer> data = new HashMap<>(list.size());
        for (Map<String, Object> map : list) {
            data.put(String.valueOf(map.get("status")), Integer.valueOf(map.get("count").toString()));
        }
        return data;
    }

    @Override
    public Page<ApplyUserSpace> findUserApply(Integer pageNumber, Integer pageSize, final Long userUU) {
        Pageable pageable = PageInfo.pageRequest(new PageRequest(pageNumber, pageSize));
        Page<ApplyUserSpace> page =  applyUserSpaceDao.findAll(new Specification<ApplyUserSpace>() {
            @Override
            public Predicate toPredicate(Root<ApplyUserSpace> root,
                                         CriteriaQuery<?> query, CriteriaBuilder cb) {
                List<Predicate> list = new ArrayList<>();
                list.add(cb.equal(root.get("userUU").as(String.class), userUU));
                Predicate[] predicates = new Predicate[list.size()];
                predicates = list.toArray(predicates);
                return cb.and(predicates);
            }
        }, pageable);
        return new PageInfo<>(page.getContent(), pageable, page.getTotalElements());
    }

    @Override
    public void agreeApply(Long userUU, Long id) {
        // 判断当前用户是否为管理员
        UserAccount loginUser = SystemSession.getUserAccount();
        Userspace userspace = userspaceDao.findOne(loginUser.getSpaceUU());
        if (loginUser.getSpaceUU().equals(userspace.getAdminUU())) {
            throw new VisibleError("不是管理员，不允许操作");
        }

        // 找到申请信息
        ApplyUserSpace applyUserSpace = applyUserSpaceDao.findOne(id);
        if (!userUU.equals(applyUserSpace.getUserUU()) || !loginUser.getSpaceUU().equals(applyUserSpace.getSpaceUU())) {
            // 简单的校验下参数
            throw new VisibleError("参数错误");
        }

        // 修改状态
        applyUserSpace.setStatus(Status.AGREE.getCode());
        applyUserSpace.setProcessTime(new Timestamp(System.currentTimeMillis()));
        applyUserSpaceDao.save(applyUserSpace);

        // 将用户添加到企业
        userService.bindUserspace(AccountConfig.ACCOUNT_CENTER, userUU, loginUser.getSpaceUU());
    }

    @Override
    public void disagreeApply(Long userUU, Long id) {
        // 判断当前用户是否为管理员
        UserAccount loginUser = SystemSession.getUserAccount();
        Userspace userspace = userspaceDao.findOne(loginUser.getSpaceUU());
        if (loginUser.getSpaceUU().equals(userspace.getAdminUU())) {
            throw new VisibleError("不是管理员，不允许操作");
        }

        // 找到申请信息
        ApplyUserSpace applyUserSpace = applyUserSpaceDao.findOne(id);
        if (!userUU.equals(applyUserSpace.getUserUU())) {
            // 简单的校验下参数
            throw new VisibleError("参数错误");
        }

        // 修改状态
        applyUserSpace.setStatus(Status.DISAGREE.getCode());
        applyUserSpace.setProcessTime(new Timestamp(System.currentTimeMillis()));
        applyUserSpaceDao.save(applyUserSpace);
    }

    @Override
    public Page<ApplyUserSpace> findApplyByUserUU(final Long userUU, int page, int size) {
        Pageable pageable = PageInfo.pageRequest(page, size);
        Page<ApplyUserSpace> pApply = applyUserSpaceDao.findAll(new Specification<ApplyUserSpace>() {
            @Override
            public Predicate toPredicate(Root<ApplyUserSpace> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                List<Predicate> list = new ArrayList<>();
                list.add(cb.equal(root.join("user", JoinType.INNER).get("userUU").as(Long.class), userUU));
                Predicate[] predicates = new Predicate[list.size()];
                predicates = list.toArray(predicates);
                return cb.and(predicates);
            }
        }, pageable);
        return new PageInfo<>(pApply.getContent(), pageable, pApply.getTotalElements());
    }

    @Override
    public void auditApply(Long userUU, Long id, Integer status) {
        // 找到申请信息
        ApplyUserSpace applyUserSpace = applyUserSpaceDao.findOne(id);
        if (!userUU.equals(applyUserSpace.getUserUU())) {
            // 简单的校验下参数
            throw new VisibleError("参数错误");
        }

        // 修改状态
        applyUserSpace.setStatus(status);
        applyUserSpace.setProcessTime(new Timestamp(System.currentTimeMillis()));
        applyUserSpace = applyUserSpaceDao.save(applyUserSpace);

        if (status == Status.AGREE.getCode()) {
            // 将用户添加到企业
            userService.bindUserspace(AccountConfig.ACCOUNT_CENTER, userUU, applyUserSpace.getSpaceUU());
        }
    }

    @Override
    public Page<ApplyUserSpace> findApplyAllToMall(Integer pageNumber, Integer pageSize, final Long spaceUU, final Integer status, final String keyword) {
        Pageable pageable = PageInfo.pageRequest(new PageRequest(pageNumber, pageSize));
        Page<ApplyUserSpace> page = applyUserSpaceDao.findAll(new Specification<ApplyUserSpace>() {
            @Override
            public Predicate toPredicate(Root<ApplyUserSpace> root,
                                         CriteriaQuery<?> query, CriteriaBuilder cb) {
                List<Predicate> list = new ArrayList<>();
                list.add(cb.equal(root.get("spaceUU").as(Long.class), spaceUU));
                if (StringUtils.isEmpty(status)) {
                    list.add(cb.equal(root.get("status").as(Integer.class), Status.UNAUDIT.getCode()));
                } else {
                    list.add(cb.equal(root.get("status").as(Integer.class), status));
                }
                if (!StringUtils.isEmpty(keyword)) {
                    Predicate predicate1 = cb.like(root.join("user", JoinType.INNER).get("vipName").as(String.class), "%" + keyword + "%");
                    Predicate predicate2 = cb.like(root.join("user", JoinType.INNER).get("userUU").as(String.class), "%" + keyword + "%");
                    Predicate predicate3 = cb.like(root.join("user", JoinType.INNER).get("mobile").as(String.class), "%" + keyword + "%");
                    list.add(cb.or(predicate1, predicate2, predicate3));
                }
                Predicate[] predicates = new Predicate[list.size()];
                predicates = list.toArray(predicates);
                query.where(cb.and(predicates));
                return query.getRestriction();
            }
        }, pageable);
        return new PageInfo<>(page.getContent(), pageable, page.getTotalElements());
    }
}