package com.product.admin.service;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.product.admin.config.CmnConst;
import com.product.common.lang.StringUtils;
import com.product.core.cache.util.RedisUtil;
import com.product.core.entity.DataTableEntity;
import com.product.core.entity.FieldSetEntity;
import com.product.core.service.support.AbstractBaseService;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;

import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Author cheng
 * @Date 2022/5/10 17:59
 * @Desc 组织机构缓存
 */
@Service
public class OrganizationCacheService extends AbstractBaseService {
	protected final static String ORG_CACHE_KEY = "system:org:";
	protected final static String ORG_UUID_CACHE_KEY = "system:org:uuid:";
	protected final static String POST_DEPT_CACHE_KEY = "system:post:";
	protected final static String POST_UUID_CACHE_KEY = "system:post:uuid:";
	protected final static String DEPT_STAFF_CACHE_KEY = "system:user:dept:";
	protected final static String POST_STAFF_CACHE_KEY = "system:user:post:";
	protected final static String USER_STAFF_CACHE_KEY = "system:user:id:";


	/**
	 * 获取hash缓存 所有的value
	 *
	 * @param cacheKey
	 * @param streamFilter
	 * @return
	 */
	private static DataTableEntity getHashCache(String cacheKey, StreamFilter streamFilter) {
		DataTableEntity values = new DataTableEntity();
		// 在redis 中模糊获取key
		try (Jedis jedis = RedisUtil.getJedis();) {
			Set<byte[]> keyBytes = jedis.keys((cacheKey + "*").getBytes(StandardCharsets.UTF_8));
			if (!CollectionUtil.isEmpty(keyBytes)) {
				// 将key 序列化翻转 过滤不需要的key 转为数组
				String[] keys = keyBytes.stream().map(item -> new String(item, StandardCharsets.UTF_8))
						.filter(f -> streamFilter.keyFilter(f)).toArray(String[]::new);
				for (String key : keys) {
					//循环取出数据
					Map<String, Object> result = RedisUtil.getHash(key);
					//将map.value（Object) 转为 List (FieldSetEntity)
					List<FieldSetEntity> collect = result.values().stream().map(item -> ((FieldSetEntity) item))
							.filter(item -> streamFilter.itemFilter(item)).collect(Collectors.toList());
					if (collect != null) {
						if (values.getRows() <= 0) {
							values.setData(collect);
						} else {
							values.getData().addAll(collect);
						}
					}
				}
			}

			if (!DataTableEntity.isEmpty(values) && !StringUtils.isEmpty(values.getData().get(0).getString(CmnConst.SEQUENCE))) {
				//如果 f.getInteger = null ,default value =Integer.MAX_VALUE
				values.getData().sort(Comparator.comparing(f -> Optional.ofNullable(f.getInteger(CmnConst.SEQUENCE)).orElse(Integer.MAX_VALUE)));
			}
			values.setData(values.getData());
			return values;
		}
	}


	/**
	 * 获取指定类型的机构缓存
	 *
	 * @param type 机构类型 1 = 公司 2=部门
	 * @return
	 */
	public static DataTableEntity getOrgData(String type) {
		return getHashCache(ORG_CACHE_KEY, new StreamFilter() {
			@Override
			public boolean keyFilter(String f) {
				return !(f == null || f.startsWith(ORG_UUID_CACHE_KEY));
			}

			@Override
			public boolean itemFilter(FieldSetEntity f) {
				if (FieldSetEntity.isEmpty(f)) {
					return false;
				}
				if (!StringUtils.isEmpty(type) && !type.equals(f.getString("type"))) {
					return false;
				}
				return true;
			}
		});
	}

	/**
	 * 获取所有机构的缓存
	 *
	 * @return
	 */
	public static DataTableEntity getOrgData() {
		return getHashCache(ORG_CACHE_KEY, new StreamFilter() {
			@Override
			public boolean keyFilter(String f) {
				return !(f == null || f.startsWith(ORG_UUID_CACHE_KEY));
			}
		});
	}

	/**
	 * 获取所有岗位缓存
	 *
	 * @return
	 */
	public static DataTableEntity getPostData() {

		return getHashCache(POST_DEPT_CACHE_KEY, new StreamFilter() {
			@Override
			public boolean keyFilter(String f) {
				return !(f == null || f.startsWith(POST_UUID_CACHE_KEY));
			}
		});
	}

	/**
	 * 获取岗位缓存根据部门
	 *
	 * @param deptUuid
	 * @return
	 */
	public static DataTableEntity getPostDataByDept(String deptUuid) {
		List<FieldSetEntity> postCache = getPostCache(deptUuid);
		DataTableEntity dataTableEntity = new DataTableEntity();
		if (postCache != null) {
			dataTableEntity.setData(postCache);
		}
		return dataTableEntity;
	}

	/**
	 * 获取所有用户
	 *
	 * @return
	 */
	public static DataTableEntity getUserData() {
		return getHashCache(DEPT_STAFF_CACHE_KEY, new StreamFilter() {
		});
	}

	/**
	 * 获取部门根据公司
	 *
	 * @param org_level_uuid
	 * @return
	 */
	public static DataTableEntity getDeptDataByCompany(String org_level_uuid) {
		return getHashCache(ORG_CACHE_KEY, new StreamFilter() {
			@Override
			public boolean keyFilter(String f) {
				return !(f == null || f.startsWith(ORG_UUID_CACHE_KEY));
			}

			@Override
			public boolean itemFilter(FieldSetEntity f) {
				return org_level_uuid != null && org_level_uuid.equals(f.getString("parent_uuid")) && "2".equals(f.getString("type"));
			}
		});
	}


	/**
	 * 获取用户根据部门
	 *
	 * @param deptUuid
	 * @return
	 */
	public static DataTableEntity getUserDataByDept(String deptUuid) {
		List<FieldSetEntity> staffCacheByDept = getStaffCacheByDept(deptUuid);
		DataTableEntity dataTableEntity = new DataTableEntity();
		if (staffCacheByDept != null) {
			staffCacheByDept.sort(Comparator.comparing(f -> Optional.ofNullable(f.getInteger(CmnConst.SEQUENCE)).orElse(Integer.MAX_VALUE)));
			dataTableEntity.setData(staffCacheByDept);
		}
		return dataTableEntity;
	}

	/**
	 * 获取用户根据岗位
	 *
	 * @param postUuid
	 * @return
	 */

	public static DataTableEntity getUserDataByPost(String postUuid) {
		List<FieldSetEntity> staffCacheByPost = getStaffCacheByPost(postUuid);
		DataTableEntity dataTableEntity = new DataTableEntity();
		if (staffCacheByPost != null) {
			staffCacheByPost.sort(Comparator.comparing(f -> Optional.ofNullable(f.getInteger(CmnConst.SEQUENCE)).orElse(Integer.MAX_VALUE)));
			dataTableEntity.setData(staffCacheByPost);
		}
		return dataTableEntity;
	}


	interface StreamFilter {
		default boolean keyFilter(String f) {
			return true;
		}

		default boolean itemFilter(FieldSetEntity f) {
			return true;
		}

	}

	public void cacheOrganization(String uuid) {
		StringBuilder sql = new StringBuilder();
		sql.append("\n SELECT  ");
		sql.append("\n a.uuid,  ");
		sql.append("\n a.client_uuid,  ");
		sql.append("\n a.org_level_uuid,  ");
		sql.append("\n a.org_level_name,  ");
		sql.append("\n a.org_level_all,b.uuid parent_uuid,  ");
		sql.append("\n a.org_level_code,  ");
		sql.append("\n a.org_level_type + 1 type,a.sequence,  ");
		sql.append("\n b.org_level_all parent_org_level_all, ");
		sql.append("\n case when length(a.org_level_code_parent)>0 then b.org_level_type+1 ");
		sql.append("\n else null end as parent_type,  ");
		sql.append("\n CASE  ");
		sql.append("\n WHEN a.org_level_type = 0 THEN  ");
		sql.append("\n ifnull(( SELECT 1 FROM product_sys_org_levels c WHERE c.org_level_code_parent = a.org_level_code AND c.org_level_type = 0 and c.org_level_status=0 LIMIT 1 ), 0 ) ELSE 0  ");
		sql.append("\n END childrenCompany,  ");
		sql.append("\n ifnull(( SELECT 1 FROM product_sys_org_levels WHERE org_level_code_parent = a.org_level_code AND org_level_type = 1 and org_level_status=0 LIMIT 1 ), 0 ) childrenDept,  ");
		sql.append("\n case when a.org_level_type=1 then ifnull((select 1 from product_sys_staff_user_v where dept_uuid=a.uuid and `status`=1 limit 1 ),0) else 0 end childrenStaff, ");
		sql.append("\n CASE WHEN a.org_level_type=1 then ifnull((select 1 from product_sys_job_posts where is_used=1 and dept_uuid=a.uuid limit 1 ),0) else 0 end childrenPost, ");
		sql.append("\n CASE  ");
		sql.append("\n WHEN length( a.org_level_code_parent )> 0 THEN  ");
		sql.append("\n a.org_level_code_parent ELSE a.client_uuid  ");
		sql.append("\n END org_level_code_parent,  ");
		sql.append("\n a.org_level_type  ");
		sql.append("\n FROM  ");
		sql.append("\n product_sys_org_levels a ");
		sql.append("\n LEFT JOIN product_sys_org_levels b on  b.org_level_status=0  ");
		sql.append("\n and (a.org_level_code_parent=b.org_level_code  )");
		sql.append("\n where a.org_level_status=0  ");

		Object[] params = null;
		if (!StringUtils.isEmpty(uuid)) {
			sql.append(" AND a.uuid=? ");
			params = new Object[]{uuid};
		} else {
			RedisUtil.del(this.ORG_CACHE_KEY);
		}
		DataTableEntity dt = getBaseDao().listTable(sql.toString(), params);
		if (!DataTableEntity.isEmpty(dt)) {
			for (int i = 0; i < dt.getRows(); i++) {
				FieldSetEntity fse = dt.getFieldSetEntity(i);
				addOrgCache(fse);
			}
		}

	}

	public void cachePost() {
		this.cachePost(null);
	}

	public void cachePost(String uuid) {
		StringBuilder sql = new StringBuilder();
		sql.append("\n select a.sequence,3 type,a.uuid,a.job_post_name,a.dept_uuid,b.org_level_all,org_level_code, ");
		sql.append("\n (select 1 from product_sys_staff_user_v  c where a.uuid=job_post_uuid and c.`status`=1 limit 1 ) childrenStaff ");
		sql.append("\n from product_sys_job_posts  a   ");
		sql.append("\n join product_sys_org_levels b on a.dept_uuid=b.uuid and b.org_level_type=1  ");
		Object[] params = null;
		if (!StringUtils.isEmpty(uuid)) {
			sql.append(" where a.uuid=? ");
			params = new Object[]{uuid};
		} else {
			RedisUtil.del(this.POST_DEPT_CACHE_KEY);
		}
		DataTableEntity dt = getBaseDao().listTable(sql.toString(), params);
		for (int i = 0; !DataTableEntity.isEmpty(dt) && i < dt.getRows(); i++) {
			addPostCache(dt.getFieldSetEntity(i));
		}
	}

	public void cacheStaff() {
		this.cacheStaff(null);
	}

	public void cacheStaff(String uuid) {
		StringBuilder sql = new StringBuilder();
		sql.append("\n SELECT ");
		sql.append("\n staff.user_id,users.uuid,staff.sequence,staff.sex, ");
		sql.append("\n staff.uuid staff_uuid, ");
		sql.append("\n user_name, user_name show_name,user_account, ");
		sql.append("\n dept_uuid,org.org_level_code, ");
		sql.append("\n job_post_uuid,staff.org_level_uuid,org.org_level_all, ");
		sql.append("\n 4 type ");
		sql.append("\n FROM ");
		sql.append("\n product_sys_staffs staff ");
		sql.append("\n JOIN product_sys_users users ON staff.user_id = users.user_id ");
		sql.append("\n AND users.`status` =1 ");
		Object[] params = null;
		if (!StringUtils.isEmpty(uuid)) {
			sql.append(" and users.uuid=? ");
			params = new Object[]{uuid};
		} else {
			RedisUtil.del(this.POST_STAFF_CACHE_KEY);
			RedisUtil.del(this.DEPT_STAFF_CACHE_KEY);
			RedisUtil.del(this.USER_STAFF_CACHE_KEY);
		}

		sql.append("\n JOIN product_sys_org_levels org on org.uuid=staff.dept_uuid and org.org_level_type=1 and org_level_status=0 ");
		DataTableEntity dt = getBaseDao().listTable(sql.toString(), params);
		for (int i = 0; !DataTableEntity.isEmpty(dt) && i < dt.getRows(); i++) {
			addStaffCache(dt.getFieldSetEntity(i));
		}

	}

	/**
	 * 员工缓存
	 *
	 * @param fse
	 */
	public void addStaffCache(FieldSetEntity fse) {
		if (!FieldSetEntity.isEmpty(fse)) {
			RedisUtil.setHash(this.DEPT_STAFF_CACHE_KEY + fse.getString(CmnConst.DEPT_UUID), fse.getUUID(), fse);
			RedisUtil.setHash(this.POST_STAFF_CACHE_KEY + fse.getString("job_post_uuid"), fse.getUUID(), fse);
			RedisUtil.setHash(this.USER_STAFF_CACHE_KEY, fse.getString("user_id"), fse);
		}
	}

	public static List<FieldSetEntity> getStaffCacheByDept(String dept_uuid) {
		if (!StringUtils.isEmpty((dept_uuid)) && RedisUtil.exists(DEPT_STAFF_CACHE_KEY + dept_uuid)) {
			Collection<Object> values = RedisUtil.getHash(DEPT_STAFF_CACHE_KEY + dept_uuid).values();
			return BeanUtil.copyToList(values, FieldSetEntity.class);
		}
		return null;
	}

	public static FieldSetEntity getStaffCacheByUserId(String userId) {
		if (StringUtils.isEmpty(userId)) {
			return null;
		}
		return (FieldSetEntity) RedisUtil.getHash(USER_STAFF_CACHE_KEY, userId);
	}

	public static List<FieldSetEntity> getStaffCacheByPost(String post_uuid) {
		if (!StringUtils.isEmpty((post_uuid)) && RedisUtil.exists(POST_STAFF_CACHE_KEY + post_uuid)) {
			Collection<Object> values = RedisUtil.getHash(POST_STAFF_CACHE_KEY + post_uuid).values();
			return BeanUtil.copyToList(values, FieldSetEntity.class);
		}
		return null;
	}

	/**
	 * 岗位缓存
	 *
	 * @param fse
	 */
	public void addPostCache(FieldSetEntity fse) {
		if (!FieldSetEntity.isEmpty(fse) && !StringUtils.isEmpty(fse.getUUID())) {
			RedisUtil.setHash(POST_DEPT_CACHE_KEY + fse.getString(CmnConst.DEPT_UUID), fse.getUUID(), fse);
			RedisUtil.set(POST_UUID_CACHE_KEY + fse.getUUID(), new Object[]{fse.getString("job_post_name"), fse.getString(CmnConst.DEPT_UUID)});
		}
	}

	public static List<FieldSetEntity> getPostCache(String dept_uuid) {
		if (!StringUtils.isEmpty((dept_uuid)) && RedisUtil.exists(POST_DEPT_CACHE_KEY + dept_uuid)) {
			Collection<Object> values = RedisUtil.getHash(POST_DEPT_CACHE_KEY + dept_uuid).values();
			return BeanUtil.copyToList(values, FieldSetEntity.class);
		}
		return null;
	}

	public static Object[] getPostCacheByUUID(String uuid) {
		if (!StringUtils.isEmpty((uuid)) && RedisUtil.exists(POST_UUID_CACHE_KEY + uuid)) {
			Object[] values = (Object[]) RedisUtil.get(POST_UUID_CACHE_KEY + uuid);
			return values;
		}
		return null;
	}

	/**
	 * 组织机构表缓存
	 *
	 * @param fse
	 */
	public void addOrgCache(FieldSetEntity fse) {
		if (!FieldSetEntity.isEmpty(fse) && !StringUtils.isEmpty(fse.getUUID())) {
			RedisUtil.setHash(this.ORG_CACHE_KEY + fse.getString(CmnConst.ORG_LEVEL_CODE_PARENT), fse.getUUID(), fse);
			Map<String, Object> orgMap = new HashMap<>();
			orgMap.put(CmnConst.ORG_LEVEL_NAME, fse.getString(CmnConst.ORG_LEVEL_NAME));
			orgMap.put(CmnConst.ORG_LEVEL_CODE, fse.getString(CmnConst.ORG_LEVEL_CODE));
			orgMap.put(CmnConst.ORG_LEVEL_CODE_PARENT, fse.getString(CmnConst.ORG_LEVEL_CODE_PARENT));
			orgMap.put(CmnConst.ORG_LEVEL_UUID, fse.getString(CmnConst.ORG_LEVEL_UUID));
			orgMap.put(CmnConst.ORG_LEVEL_ALL, fse.getString(CmnConst.ORG_LEVEL_ALL));
			orgMap.put("uuid", fse.getUUID());
			orgMap.put("parent_uuid", fse.getString("parent_uuid"));
			orgMap.put("parent_type", fse.getString("parent_type"));
			RedisUtil.set(this.ORG_UUID_CACHE_KEY + fse.getUUID(), orgMap);

		}
	}

	public static Map<String, Object> getOrgCacheByUuid(String uuid) {
		if (!StringUtils.isEmpty(uuid) && RedisUtil.exists(ORG_UUID_CACHE_KEY + uuid)) {
			return (Map<String, Object>) RedisUtil.get(ORG_UUID_CACHE_KEY + uuid);
		}
		return null;
	}


	public static List<FieldSetEntity> getOrgCache(String org_level_code_parent) {
		if (!StringUtils.isEmpty((org_level_code_parent)) && RedisUtil.exists(ORG_CACHE_KEY + org_level_code_parent)) {
			Collection<Object> values = RedisUtil.getHash(ORG_CACHE_KEY + org_level_code_parent).values();
			return BeanUtil.copyToList(values, FieldSetEntity.class);
		}
		return null;
	}
}