const NBTTagString = Java.type('net.minecraft.nbt.NBTTagString');

let utils = {
    addLore: function(item, prefix, value){
        
        const list = item
            .getNBT()
            .getCompoundTag("tag")
            .getCompoundTag("display")
            .getTagMap()
            .get("Lore")
    
        let done = false
        // Gets the current lore lines
        for (let i = 0; i < list.func_74745_c(); i++) {
            if (String(list.func_150307_f(i)).startsWith(prefix)){
                list.func_150304_a(i, new NBTTagString(prefix+value));
                done = true
            }
        }
        if(!done){
            list.func_74742_a( new NBTTagString(prefix+value))
        }
    
        item
            .getNBT()
            .getCompoundTag("tag")
            .getCompoundTag("display")
            .getRawNBT()
            .func_74782_a("Lore", list);
    },
    getSBID: function(item){
        return item?.getNBT()?.getCompoundTag("tag")?.getCompoundTag("ExtraAttributes")?.getString("id") || null
    },
    calculateDistance: function(p1, p2) {
        var a = p2[0] - p1[0];
        var b = p2[1] - p1[1];
        var c = p2[2] - p1[2];
    
        let ret = Math.hypot(a,b,c)
    
        if(ret<0){
            ret *= -1
        }
        return ret;
    },
    calculateDistanceQuick: function(p1, p2) {
        var a = p2[0] - p1[0];
        var b = p2[1] - p1[1];
        var c = p2[2] - p1[2];
    
        let ret = a * a + b * b + c * c
    
        if(ret<0){
            ret *= -1
        }
        return ret;
    },
    /**
     * Please try not to use this
     * it has O(n!)
     * only use if points < 10 or something
     * D:
     * @param {*} startPoint 
     * @param {*} points 
     * @returns 
     */
    fastestPathThrough:function(startPoint, points){
        let ret = []
        while(ret.length<points.length){
            ret.push(ret.length)
        }
        
        let allOrders = utils.permutation(ret)
    
        let lastOrder = []
        let lastOrderLength = Infinity
       
        for(let i = 0;i<allOrders.length;i++){
            let order = allOrders[i]
            let lastPoint = startPoint
            let positions = order.map((a)=>{
                return points[a]
            })
            let len = 0
            for(let i = 0;i<positions.length;i++){
                len += utils.calculateDistance(lastPoint,positions[i])
                lastPoint = positions[i]
            }
    
            if(len < lastOrderLength){
                lastOrder = order
                lastOrderLength = len
            }
        }
        
        return lastOrder;
    },
    permutation:function(array) {
        function p(array, temp) {
            var i, x;
            if (!array.length) {
                result.push(temp);
            }
            for (i = 0; i < array.length; i++) {
                x = array.splice(i, 1)[0];
                p(array, temp.concat(x));
                array.splice(i, 0, x);
            }
        }
    
        var result = [];
        p(array, []);
        return result;
    }
}

module.exports = utils