package com.qianwen.smartman.common.utils;

import cn.hutool.crypto.Mode;
import cn.hutool.crypto.Padding;
import cn.hutool.crypto.symmetric.DES;
import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.List;
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.common.UtilAll;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.constant.TenantConstant;
import com.qianwen.core.tool.node.INode;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.StringUtil;


public class CommonUtil {
    public static String changeInstanceNameToPID(DefaultMQPushConsumer consumer) {
        String instanceName = consumer.getInstanceName();
        if ("DEFAULT".equals(consumer.getInstanceName())) {
            instanceName = UtilAll.getPid() + "#" + System.nanoTime();
        }
        return instanceName;
    }

    public static int initCapacity(int size) {
        return (int) ((size / 0.75d) + 1.0d);
    }

    /**
     * 拼接redisKey，[cacheName]::[keyPrefix][key]
     * @param cacheName 缓存名称
     * @param keyPrefix key前缀
     * @param key 最末端的key
     * @return
     */
    public static String getReallyCacheName(String cacheName, String keyPrefix, String key) {
        return cacheName.concat("::").concat(keyPrefix).concat(key);
    }

    public static String getReallyCacheName(String cacheName, String keyPrefix, String key, Object... args) {
        return StringUtil.format(cacheName.concat("::").concat(keyPrefix).concat(key), args);
    }

    public static String getDefaultPass() {
        DES des = new DES(Mode.ECB, Padding.ZeroPadding, "yw8W8jud0CoJUm6Q".getBytes());
        return des.decryptStr(TenantConstant.DEFAULT_ENCRYPTED_PASS);
    }

    public static String secToTime(Integer time) {
    	String timeStr;
    	
        int hour = 0;
        int minute = 0;
        int second = 0;
        
        if (Func.isEmpty(time) || time.intValue() <= 0) {
            return "00:00:00";
        }
        
        time = Integer.valueOf(time.intValue() / 1000);
        minute = time.intValue() / CommonConstant.SECONDS_OF_MINUTE.intValue();
        
        if (minute < CommonConstant.SECONDS_OF_MINUTE.intValue()) {   
            second = time.intValue() % CommonConstant.SECONDS_OF_MINUTE.intValue();
            timeStr = "00:" + unitFormat(minute) + ":" + unitFormat(second);
        } else {
        	hour = minute / CommonConstant.SECONDS_OF_MINUTE.intValue();
            minute %= CommonConstant.SECONDS_OF_MINUTE.intValue();
            second = time.intValue() - hour * CommonConstant.SECONDS_OF_HOUR.intValue() - minute * CommonConstant.SECONDS_OF_MINUTE.intValue();
            timeStr = unitFormat(hour) + ":" + unitFormat(minute) + ":" + unitFormat(second);
            
        }
        return timeStr;
    }

    private static String unitFormat(int i) {
        String retStr;
        if (i >= 0 && i < CommonConstant.NUMBER_ABOVE_TWO.intValue()) {
            retStr = "0" + i;
        } else {
            retStr = "" + i;
        }
        return retStr;
    }

    public static <T extends INode<T>> List<T> treeToList(List<T> items) {
        List<T> list = new ArrayList<>();
        items.forEach(forestNode -> {
            list.add(forestNode);
            recursion(forestNode, list);
        });
        return list;
    }

    private static <T extends INode<T>> void recursion(T forestNode, List<T> list) {
        if (Func.isNotEmpty(forestNode.getChildren())) {
            forestNode.getChildren().forEach(childForestNode -> {
                list.add(childForestNode);
                recursion(childForestNode, list);
            });
        }
    }

    public static <T> List<List<T>> groupList(List<T> list, int batchSize) {
    	if (Func.isEmpty(list)) {
    	      return Lists.newArrayList(); 
    	}
	    int size = list.size();
	    List<List<T>> res = Lists.newArrayList();
	    int i = 0;
	    while (i <= size) {
	      if (i + batchSize >= size) {
	        List<T> list1 = list.subList(i, size);
	        res.add(list1);
	        break;
	      } 
	      int j = i + batchSize;
	      List<T> newList = list.subList(i, j);
	      i = j;
	      res.add(newList);
	    } 
	    return res;
    }
}