package com.caimei.service.vip.impl;

import com.caimei.mapper.SystemMapper;
import com.caimei.mapper.VipMapper;
import com.caimei.model.ResponseJson;
import com.caimei.model.dto.PackageDto;
import com.caimei.model.po.*;
import com.caimei.model.vo.*;
import com.caimei.service.sys.SysMenuService;
import com.caimei.service.sys.SysRoleService;
import com.caimei.service.sys.SysUserService;
import com.caimei.service.vip.VipService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;

/**
 * Description
 *
 * @author : Aslee
 * @date : 2021/5/11
 */
@Slf4j
@Service
public class VipServiceImpl implements VipService {
    @Resource
    private VipMapper vipMapper;
    @Resource
    private SystemMapper systemMapper;
    @Resource
    private SysMenuService sysMenuService;
    @Resource
    private SysUserService sysUserService;
    @Resource
    private SysRoleService sysRoleService;

    @Override
    public ResponseJson<Integer> payVip(Integer authUserId, Integer packageId, String services, Integer payWay, Integer payStatus, Date payTime) {
        // 查询购买套餐信息
        VipPackageVo packageVo = vipMapper.getVipPackageById(packageId);
        if (null == packageVo) {
            return ResponseJson.error("会员套餐不存在", null);
        }
        // 会员生效日期
        Date beginTime = new Date();
        /*
         * 构建会员信息
         */
        AuthVipPo authVip = new AuthVipPo();
        AuthVipPo dbAuthVip = vipMapper.getAuthVipInfo(authUserId);
        if (null != dbAuthVip) {
            authVip.setId(dbAuthVip.getId());
            if (dbAuthVip.getEndTime().compareTo(beginTime) > 0) {
                // 有效期内续费,用原结束时间作为开始时间来计算结束时间
                beginTime = dbAuthVip.getEndTime();
                authVip.setBeginTime(dbAuthVip.getBeginTime());
            } else {
                // 过期重新续费，重置生效时间
                authVip.setBeginTime(beginTime);
            }
        } else {
            // 新会员
            authVip.setBeginTime(beginTime);
        }
        // 计算会员到期时间
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(beginTime);
        calendar.add(1 == packageVo.getUnit() ? Calendar.MONTH : Calendar.YEAR, packageVo.getDuration());
        Date endTime = calendar.getTime();
        // 查询未支付的当前会员套餐购买记录
        Integer dbHistoryId = vipMapper.getVipHistoryId(authUserId, packageId);
        VipHistoryPo vipHistory = new VipHistoryPo();
        vipHistory.setAuthUserId(authUserId);
        vipHistory.setPackageId(packageId);
        vipHistory.setDuration(packageVo.getDuration() + (1 == packageVo.getUnit() ? "月" : "年"));
        vipHistory.setBeginTime(beginTime);
        vipHistory.setEndTime(endTime);
        vipHistory.setPayStatus(payStatus);
        vipHistory.setPayWay(payWay);
        vipHistory.setPrice(packageVo.getPrice());
        vipHistory.setServices(services);
        vipHistory.setPayTime(payTime);
        if (null != dbHistoryId) {
            vipHistory.setId(dbHistoryId);
            // 更新未支付的当前会员购买记录
            vipMapper.updateVipHistory(vipHistory);
        } else {
            // 新增会员购买记录
            vipMapper.insertVipHistory(vipHistory);
        }
        if (2 == payWay) {
            // 赠送会员保存会员信息
            authVip.setAuthUserId(authUserId);
            authVip.setUpdateTime(new Date());
            authVip.setEndTime(endTime);
            authVip.setDelFlag(0);
            if (null != authVip.getId()) {
                // 更新会员信息
                vipMapper.updateAuthVipInfo(authVip);
                if (authVip.getBeginTime().compareTo(beginTime) >= 0) {
                    // 删除原有角色关联
                    systemMapper.deleteUserRoleRelation(authUserId);
                    // 续费重新分配角色
                    sysUserService.saveRoleRelation(authUserId, "1,2");
                }
            } else {
                // 新增会员信息
                vipMapper.insertAuthVipInfo(authVip);
                // 删除原有角色关联
                systemMapper.deleteUserRoleRelation(authUserId);
                // 分配角色
                sysUserService.saveRoleRelation(authUserId, "1,2");
            }
        }
        if (null != vipHistory.getId() && vipHistory.getId() > 0) {
            return ResponseJson.success(vipHistory.getId());
        }
        return ResponseJson.error("支付开通会员异常！", null);
    }

    @Override
    public ResponseJson configureVip(List<Map<String,Object>> packageList, List<Map<String, String>> serviceList) {
        // 删除原有的套餐及订制服务
        vipMapper.deleteVipPackages();
        vipMapper.deleteVipServices();
        // 保存套餐及订制服务
        packageList.forEach(pac->{
            PackageDto packageDto = new PackageDto();
            packageDto.setDuration(Integer.parseInt(pac.get("duration").toString()));
            packageDto.setUnit(Integer.parseInt(pac.get("unit").toString()));
            packageDto.setOriginalPrice(new BigDecimal(pac.get("originalPrice").toString()) );
            packageDto.setPrice(new BigDecimal(pac.get("price").toString()));
            vipMapper.insertVipPackage(packageDto);
        });
        serviceList.forEach(service -> vipMapper.insertVipService(service.get("name")));
        return ResponseJson.success();
    }

    @Override
    public ResponseJson<VipConfigurationVo> configureVipForm() {
        List<VipPackageVo> packageList = vipMapper.getVipPackageList();
        List<VipServiceVo> serviceList = vipMapper.getVipServiceList();
        VipConfigurationVo vipConfiguration = new VipConfigurationVo();
        vipConfiguration.setPackageList(packageList);
        vipConfiguration.setServiceList(serviceList);
        return ResponseJson.success(vipConfiguration);
    }

    @Override
    public ResponseJson<PageInfo<VipListVo>> vipList(String shopName, Integer shopType, Integer vipStatus, String mobile, String linkMan, Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<VipListVo> vipList = vipMapper.getVipList(shopName, shopType, vipStatus, mobile, linkMan);
        PageInfo<VipListVo> pageData = new PageInfo<>(vipList);
        return ResponseJson.success(pageData);
    }

    @Override
    public ResponseJson<PageInfo<VipHistoryListVo>> vipHistoryList(Integer authUserId, Integer vipPackageId, Integer vipStatus, String payBeginTime, String payEndTime, String endBeginTime, String endEndTime, Integer pageNum, Integer pageSize) {
        if (null == authUserId) {
            return ResponseJson.error("参数异常，供应商用户id不能为空", null);
        }
        PageHelper.startPage(pageNum, pageSize);
        List<VipHistoryListVo> vipHistoryList = vipMapper.getVipHistoryList(authUserId, vipPackageId, vipStatus, payBeginTime, payEndTime, endBeginTime, endEndTime);
        PageInfo<VipHistoryListVo> pageData = new PageInfo<>(vipHistoryList);
        return ResponseJson.success(pageData);
    }

    @Override
    public ResponseJson<VipInfoVo> getVipInfo(Integer authUserId) {
        if (null == authUserId) {
            return ResponseJson.error("参数异常，供应商用户id不能为空", null);
        }
        VipInfoVo vipInfo = vipMapper.getVipInfo(authUserId);
        if (null == vipInfo) {
            return ResponseJson.error("供应商用户不存在", null);
        }
        Integer freeDayLeft = vipInfo.getFreeDayLeft();
        vipInfo.setFreeUseFlag(freeDayLeft > 0 ? 1 : 0);
        vipInfo.setTipType(0);
        if (0 == vipInfo.getVipStatus()) {
            // 会员到期
            vipInfo.setTipType(4);
        } else if (1 == vipInfo.getVipStatus() && vipInfo.getEndDayLeft() <= 30) {
            // 会员即将到期
            vipInfo.setTipType(3);
        } else if (3 == vipInfo.getVipStatus()) {
            if (freeDayLeft > 0 && freeDayLeft <= 30) {
                // 试用即将到期
                vipInfo.setTipType(1);
            } else if (freeDayLeft < 0) {
                // 试用到期
                vipInfo.setTipType(2);
            }
        }
        return ResponseJson.success(vipInfo);
    }

    @Override
    public ResponseJson<List<VipPackageVo>> vipPackageList() {
        List<VipPackageVo> vipPackageList = vipMapper.getVipPackageList();
        return ResponseJson.success(vipPackageList);
    }

    @Override
    public ResponseJson<Map<String, Object>> vipMenusForm() {
        HashMap<String, Object> map = new HashMap<>();
        List<SysMenu> baseMenuList = vipMapper.getBaseMenuList();
        List<SysMenu> upMenuList = vipMapper.getUpMenuList();
        map.put("baseMenuList", baseMenuList);
        map.put("upMenuList", upMenuList);
        return ResponseJson.success(map);
    }

    @Override
    public ResponseJson vipMenusConfigure(List<Map<String, Object>> baseMenuList, List<Map<String, Object>> upMenuList) {
        systemMapper.deleteRoleMenuRelation(1);
        systemMapper.deleteRolePermissionRelation(1);
        systemMapper.deleteRoleMenuRelation(2);
        systemMapper.deleteRolePermissionRelation(2);
        Set<Integer> baseMenuIdSet = new HashSet<>();
        Set<Integer> basePermissionIdSet = new HashSet<>();
        for (Map<String,Object> menu : baseMenuList) {
            SysMenu baseMenu = new SysMenu();
            baseMenu.setBaseFlag(1);
            String menuId = menu.get("id").toString();
            baseMenu.setId(Integer.parseInt(menuId));
            baseMenu.setStatus(Integer.parseInt(menu.get("status").toString()));
            baseMenu.setTitle(menu.get("title").toString());
            // 更新菜单
            systemMapper.updateShopMenu(baseMenu);
            getAllBaseMenuIds(baseMenu, baseMenuIdSet, basePermissionIdSet);
        }
        baseMenuIdSet.forEach(menuId -> {
            // 保存角色菜单关系
            systemMapper.insertRoleMenuRelation(1, menuId);
        });
        basePermissionIdSet.forEach(permissionId->{
            // 保存角色权限关系
            systemMapper.insertRolePermissionRelation(1, permissionId);
        });
        upMenuList.forEach(menu->{
            Set<Integer> vipMenuIdSet = new HashSet<>();
            Set<Integer> vipPermissionIdSet = new HashSet<>();
            SysMenu upMenu = new SysMenu();
            Integer menuId = Integer.parseInt(menu.get("id").toString());
            upMenu.setBaseFlag(0);
            upMenu.setParentId(0);
            upMenu.setId(menuId);
            upMenu.setStatus(Integer.parseInt(menu.get("status").toString()));
            upMenu.setTitle(menu.get("title").toString());
            systemMapper.updateShopMenu(upMenu);
            // 获取菜单下所有权限id
            List<SysPermission> permissionList = systemMapper.getPermissionList(menuId);
            Integer dbRoleId = systemMapper.getVipRoleIdByMenuId(menuId);
            sysMenuService.saveVipMenu(upMenu, permissionList);
            Integer roleId = systemMapper.getVipRoleIdByMenuId(menuId);
            // 获取子菜单列表
            List<SysMenu> childMenuList = systemMapper.getMenuList(menuId, 2, null);
            childMenuList.forEach(childMenu->{
                getAllVipMenuIds(childMenu, vipMenuIdSet, vipPermissionIdSet);
            });
            if (null == dbRoleId) {
                vipMenuIdSet.forEach(vipMenuId-> systemMapper.insertRoleMenuRelation(roleId, vipMenuId));
                vipPermissionIdSet.forEach(vipPermissionId-> systemMapper.insertRolePermissionRelation(roleId, vipPermissionId));
            }
        });
        return ResponseJson.success();
    }

    /**
     * 获取一颗菜单树下的所有菜单id和权限id
     */
    private ResponseJson<Void> getAllBaseMenuIds(SysMenu menu, Set<Integer> menuIdSet, Set<Integer> permissionIdSet) {
        // 删除基础菜单与会员角色的关联
        Integer menuId = menu.getId();
        menuIdSet.add(menuId);
        Integer roleId = systemMapper.getVipRoleIdByMenuId(menuId);
        if (null != roleId) {
            systemMapper.deleteRole(roleId);
            systemMapper.deleteRoleMenuRelation(roleId);
            systemMapper.deleteRolePermissionRelation(roleId);
        }
        // 获取菜单下所有权限id
        List<Integer> permissionIdList = systemMapper.getPermissionIds(menuId);
        permissionIdSet.addAll(permissionIdList);
        // 获取子菜单列表
        List<SysMenu> childMenuList = systemMapper.getMenuList(menuId, 2, null);
        // 遍历获取子菜单id和
        childMenuList.forEach(childMenu -> getAllBaseMenuIds(childMenu, menuIdSet, permissionIdSet));
        return ResponseJson.success();
    }

    /**
     * 获取一颗菜单树下的所有菜单id和权限id
     */
    private ResponseJson<Void> getAllVipMenuIds(SysMenu menu, Set<Integer> menuIdSet, Set<Integer> permissionIdSet) {
        Integer menuId = menu.getId();
        menuIdSet.add(menuId);
        // 获取菜单下所有权限id
        List<Integer> permissionIdList = systemMapper.getPermissionIds(menuId);
        permissionIdSet.addAll(permissionIdList);
        // 获取子菜单列表
        List<SysMenu> childMenuList = systemMapper.getMenuList(menuId, 2, null);
        // 遍历获取子菜单id和
        childMenuList.forEach(childMenu -> getAllBaseMenuIds(childMenu, menuIdSet, permissionIdSet));
        return ResponseJson.success();
    }

    @Override
    public ResponseJson<List<SysMenu>> vipServicesForm(Integer authUserId) {
        List<SysMenu> vipServiceList = systemMapper.getVipMenuList();
        List<Integer> vipRoleList = systemMapper.getVipRoleIdList(authUserId);
        vipServiceList.forEach(vipService->{
            vipService.setCheckFlag(0);
            vipRoleList.forEach(roleId->{
                if (roleId.equals(vipService.getRoleId())) {
                    vipService.setCheckFlag(1);
                }
            });
        });
        return ResponseJson.success(vipServiceList);
    }

    @Override
    public ResponseJson vipServicesConfigure(Integer authUserId, String roleIds) {
        if (null == authUserId) {
            return ResponseJson.error("参数异常，用户id不能为空");
        }
        // 删除原有角色关联
        systemMapper.deleteUserRoleRelation(authUserId);
        // 保存用户角色关系
        sysUserService.saveRoleRelation(authUserId, roleIds + ",1,2");
        return ResponseJson.success();
    }
}