package com.qianwen.smartman.modules.system.service.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.qianwen.core.cache.utils.CacheUtil;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseServiceImpl;
import com.qianwen.core.tenant.TenantId;
import com.qianwen.core.tool.constant.BladeConstant;
import com.qianwen.core.tool.jackson.JsonUtil;
import com.qianwen.core.tool.support.Kv;
import com.qianwen.core.tool.utils.DesUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.common.cache.ParamCache;
import com.qianwen.smartman.common.constant.TenantConstant;
import com.qianwen.smartman.common.utils.CommonUtil;
import com.qianwen.smartman.modules.auth.enums.UserEnum;
import com.qianwen.smartman.modules.system.entity.Dept;
import com.qianwen.smartman.modules.system.entity.DictBiz;
import com.qianwen.smartman.modules.system.entity.Menu;
import com.qianwen.smartman.modules.system.entity.Post;
import com.qianwen.smartman.modules.system.entity.Role;
import com.qianwen.smartman.modules.system.entity.RoleMenu;
import com.qianwen.smartman.modules.system.entity.Tenant;
import com.qianwen.smartman.modules.system.entity.User;
import com.qianwen.smartman.modules.system.mapper.TenantMapper;
import com.qianwen.smartman.modules.system.service.IDataScopeManagerService;
import com.qianwen.smartman.modules.system.service.IDictBizService;
import com.qianwen.smartman.modules.system.service.IMenuService;
import com.qianwen.smartman.modules.system.service.IPostService;
import com.qianwen.smartman.modules.system.service.IRoleMenuService;
import com.qianwen.smartman.modules.system.service.IRoleService;
import com.qianwen.smartman.modules.system.service.ITenantService;
import com.qianwen.smartman.modules.system.service.IUserService;

@Service
public class TenantServiceImpl extends BaseServiceImpl<TenantMapper, Tenant> implements ITenantService {
    private final TenantId tenantId;
    private final IRoleService roleService;
    private final IMenuService menuService;
    private final IDataScopeManagerService deptService;
    private final IPostService postService;
    private final IRoleMenuService roleMenuService;
    private final IDictBizService dictBizService;
    private final IUserService userService;


    public TenantServiceImpl(final TenantId tenantId, final IRoleService roleService, final IMenuService menuService, final IDataScopeManagerService deptService, final IPostService postService, final IRoleMenuService roleMenuService, final IDictBizService dictBizService, final IUserService userService) {
        this.tenantId = tenantId;
        this.roleService = roleService;
        this.menuService = menuService;
        this.deptService = deptService;
        this.postService = postService;
        this.roleMenuService = roleMenuService;
        this.dictBizService = dictBizService;
        this.userService = userService;
    }

    @Override // org.springblade.modules.system.service.ITenantService
    public IPage<Tenant> selectTenantPage(IPage<Tenant> page, Tenant tenant) {
        return page.setRecords(((TenantMapper) this.baseMapper).selectTenantPage(page, tenant));
    }

    @Override // org.springblade.modules.system.service.ITenantService
    public Tenant getByTenantId(String tenantId) {
        return getOne(Wrappers.<Tenant>query().lambda().eq(Tenant::getTenantId, tenantId));
    }

    @Override // org.springblade.modules.system.service.ITenantService
    @Transactional(rollbackFor = {Exception.class})
    public boolean submitTenant(Tenant tenant) {
        if (Func.isEmpty(tenant.getId())) {
        	List<Tenant> tenants = this.baseMapper.selectList(Wrappers.<Tenant>query().lambda().eq(Tenant::getIsDeleted, 0));
            List<String> codes = tenants.stream().map(Tenant::getTenantId).collect(Collectors.toList());
            /*
            List<Tenant> tenants = ((TenantMapper) this.baseMapper).selectList((Wrapper) Wrappers.query().lambda().eq((v0) -> {
                return v0.getIsDeleted();
            }, 0));
            List<String> codes = (List) tenants.stream().map((v0) -> {
                return v0.getTenantId();
            }).collect(Collectors.toList());*/
            String tenantId = getTenantId(codes);
            tenant.setTenantId(tenantId);
            int accountNumber = Func.toInt(ParamCache.getValue(TenantConstant.ACCOUNT_NUMBER_KEY), TenantConstant.DEFAULT_ACCOUNT_NUMBER.intValue());
            tenant.setAccountNumber(Integer.valueOf(accountNumber));
            Role role = new Role();
            role.setTenantId(tenantId);
            role.setParentId(BladeConstant.TOP_PARENT_ID);
            role.setRoleName("管理员");
            role.setRoleAlias("admin");
            role.setSort(2);
            role.setIsDeleted(0);
            this.roleService.save(role);
            LinkedList<Menu> userMenus = new LinkedList<>();
            List<String> menuCodes = Func.toStrList(ParamCache.getValue(TenantConstant.ACCOUNT_MENU_CODE_KEY));
            List<Menu> menus = getMenus(menuCodes.size() > 0 ? menuCodes : TenantConstant.MENU_CODES, userMenus);
            List<RoleMenu> roleMenus = new ArrayList<>();
            menus.forEach(menu -> {
                RoleMenu roleMenu = new RoleMenu();
                roleMenu.setMenuId(menu.getId());
                roleMenu.setRoleId(role.getId());
                roleMenus.add(roleMenu);
            });
            this.roleMenuService.saveBatch(roleMenus);
            Dept dept = new Dept();
            dept.setTenantId(tenantId);
            dept.setParentId(BladeConstant.TOP_PARENT_ID);
            dept.setAncestors(String.valueOf(BladeConstant.TOP_PARENT_ID));
            dept.setDeptName(tenant.getTenantName());
            dept.setFullName(tenant.getTenantName());
            dept.setDeptCategory(1);
            dept.setSort(2);
            dept.setIsDeleted(0);
            this.deptService.save(dept);
            Post post = new Post();
            post.setTenantId(tenantId);
            post.setCategory(1);
            post.setPostCode("ceo");
            post.setPostName("首席执行官");
            post.setSort(1);
            this.postService.save(post);
            LinkedList<DictBiz> dictBizs = new LinkedList<>();
            List<DictBiz> dictBizList = getDictBizs(tenantId, dictBizs);
            this.dictBizService.saveBatch(dictBizList);
            User user = new User();
            user.setTenantId(tenantId);
            user.setRealName("admin");
            user.setAccount("admin");
            String password = Func.toStr(ParamCache.getValue(TenantConstant.PASS_KEY), CommonUtil.getDefaultPass());
            user.setPassword(password);
            user.setRoleId(String.valueOf(role.getId()));
            user.setDeptId(String.valueOf(dept.getId()));
            user.setPostId(String.valueOf(post.getId()));
            user.setBirthday(new Date());
            user.setSex(1);
            user.setUserType(Integer.valueOf(UserEnum.WEB.getCategory()));
            user.setIsDeleted(0);
            this.userService.submit(user);
        }
        CacheUtil.clear("blade:sys", tenant.getTenantId());
        return super.saveOrUpdate(tenant);
    }

    @Override // org.springblade.modules.system.service.ITenantService
    @Transactional(rollbackFor = {Exception.class})
    public boolean removeTenant(List<Long> ids) {
    	List<String> tenantIds = list(Wrappers.<Tenant>query().lambda().in(Tenant::getId, ids)).stream().map(tenant -> Func.toStr(tenant.getTenantId())).distinct().collect(Collectors.toList());
    	/*
        List<String> tenantIds = (List) list((Wrapper) Wrappers.query().lambda().in((v0) -> {
            return v0.getId();
        }, ids)).stream().map(tenant -> {
            return Func.toStr(tenant.getTenantId());
        }).distinct().collect(Collectors.toList());*/
        CacheUtil.clear("blade:sys", tenantIds);
        if (tenantIds.contains("000000")) {
            throw new ServiceException("不可删除管理租户!");
        }
        boolean tenantTemp = deleteLogic(ids);
        boolean userTemp = this.userService.remove(Wrappers.<User>query().lambda().in(User::getTenantId, tenantIds));
        /*
        boolean userTemp = this.userService.remove((Wrapper) Wrappers.query().lambda().in((v0) -> {
            return v0.getTenantId();
        }, tenantIds));*/
        return tenantTemp && userTemp;
    }

    @Override // org.springblade.modules.system.service.ITenantService
    public boolean setting(Integer accountNumber, Date expireTime, String ids) {
    	List<String> tenantIds = list(Wrappers.<Tenant>query().lambda().in(Tenant::getId, new Object[] { ids })).stream().map(tenant -> Func.toStr(tenant.getTenantId())).distinct().collect(Collectors.toList());
    	/*
        List<String> tenantIds = (List) list((Wrapper) Wrappers.query().lambda().in((v0) -> {
            return v0.getId();
        }, new Object[]{ids})).stream().map(tenant -> {
            return Func.toStr(tenant.getTenantId());
        }).distinct().collect(Collectors.toList());*/
        CacheUtil.clear("blade:sys", tenantIds);
        Func.toLongList(ids).forEach(id -> {
            Kv kv = Kv.create().set("accountNumber", accountNumber).set("expireTime", expireTime).set("id", id);
            String licenseKey = DesUtil.encryptToHex(JsonUtil.toJson(kv), TenantConstant.DES_KEY);
            update(Wrappers.<Tenant>update().lambda().set(Tenant::getAccountNumber, accountNumber)
            		.set(Tenant::getExpireTime, expireTime)
            		.set(Tenant::getLicenseKey, licenseKey).eq(Tenant::getId, id));
            /*
            update((Wrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) Wrappers.update().lambda().set((v0) -> {
                return v0.getAccountNumber();
            }, accountNumber)).set((v0) -> {
                return v0.getExpireTime();
            }, expireTime)).set((v0) -> {
                return v0.getLicenseKey();
            }, licenseKey)).eq((v0) -> {
                return v0.getId();
            }, id));*/
        });
        return true;
    }

    private String getTenantId(List<String> codes) {
        String code = this.tenantId.generate();
        if (codes.contains(code)) {
            return getTenantId(codes);
        }
        return code;
    }

    private List<Menu> getMenus(List<String> codes, LinkedList<Menu> menus) {
        codes.forEach(code -> {
        	Menu menu = this.menuService.getOne(Wrappers.<Menu>query().lambda().eq(Menu::getCode, code).eq(Menu::getIsDeleted, 0));
        	/*
            Menu menu = (Menu) this.menuService.getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
                return v0.getCode();
            }, code)).eq((v0) -> {
                return v0.getIsDeleted();
            }, 0));*/
            if (menu != null) {
                menus.add(menu);
                recursionMenu(menu.getId(), menus);
            }
        });
        return menus;
    }

    private void recursionMenu(Long parentId, LinkedList<Menu> menus) {
    	List<Menu> menuList = this.menuService.list(Wrappers.<Menu>query().lambda().eq(Menu::getParentId, parentId).eq(Menu::getIsDeleted, 0));
    	/*
        List<Menu> menuList = this.menuService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getParentId();
        }, parentId)).eq((v0) -> {
            return v0.getIsDeleted();
        }, 0));*/
        menus.addAll(menuList);
        menuList.forEach(menu -> {
            recursionMenu(menu.getId(), menus);
        });
    }

    private List<DictBiz> getDictBizs(String tenantId, LinkedList<DictBiz> dictBizs) {
    	List<DictBiz> dictBizList = this.dictBizService.list(Wrappers.<DictBiz>query().lambda()
    			.eq(DictBiz::getParentId, BladeConstant.TOP_PARENT_ID)
    			.eq(DictBiz::getIsDeleted, 0));
    	/*
        List<DictBiz> dictBizList = this.dictBizService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getParentId();
        }, BladeConstant.TOP_PARENT_ID)).eq((v0) -> {
            return v0.getIsDeleted();
        }, 0));*/
        dictBizList.forEach(dictBiz -> {
            Long oldParentId = dictBiz.getId();
            Long newParentId = Long.valueOf(IdWorker.getId());
            dictBiz.setId(newParentId);
            dictBiz.setTenantId(tenantId);
            dictBizs.add(dictBiz);
            recursionDictBiz(tenantId, oldParentId, newParentId, dictBizs);
        });
        return dictBizs;
    }

    private void recursionDictBiz(String tenantId, Long oldParentId, Long newParentId, LinkedList<DictBiz> dictBizs) {
    	List<DictBiz> dictBizList = this.dictBizService.list(Wrappers.<DictBiz>query().lambda()
    			.eq(DictBiz::getParentId, oldParentId)
    			.eq(DictBiz::getIsDeleted, 0));
    	/*
        List<DictBiz> dictBizList = this.dictBizService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getParentId();
        }, oldParentId)).eq((v0) -> {
            return v0.getIsDeleted();
        }, 0));*/
        dictBizList.forEach(dictBiz -> {
            Long oldSubParentId = dictBiz.getId();
            Long newSubParentId = Long.valueOf(IdWorker.getId());
            dictBiz.setId(newSubParentId);
            dictBiz.setTenantId(tenantId);
            dictBiz.setParentId(newParentId);
            dictBizs.add(dictBiz);
            recursionDictBiz(tenantId, oldSubParentId, newSubParentId, dictBizs);
        });
    }
}