function newGovernanceFunctionLibraryDelegationProgram() {
    let thisObject = {
        calculate: calculate
    }

    return thisObject

    function calculate(
        pools,
        userProfiles
    ) {

        /* Bonus Calculation is here */
        UI.projects.governance.utilities.bonusProgram.run(
            pools,
            userProfiles,
            "delegationProgram",
            "Delegation-Bonus"
        )
        /*
        We will first reset all the delegate power, and then distribute it.
        */
        for (let i = 0; i < userProfiles.length; i++) {
            let userProfile = userProfiles[i]

            if (userProfile.tokenPowerSwitch === undefined) { continue }
            if (userProfile.tokenPowerSwitch.delegationProgram === undefined) { continue }
            if (userProfile.tokenPowerSwitch.delegationProgram.payload === undefined) { continue }

            resetProgram(userProfile.tokenPowerSwitch.delegationProgram)
        }
        for (let i = 0; i < userProfiles.length; i++) {
            let userProfile = userProfiles[i]

            if (userProfile.tokenPowerSwitch === undefined) { continue }
            if (userProfile.tokenPowerSwitch.delegationProgram === undefined) { continue }
            if (userProfile.tokenPowerSwitch.delegationProgram.payload === undefined) { continue }

            userProfile.tokenPowerSwitch.delegationProgram.payload.delegationProgram.programPower = userProfile.tokenPowerSwitch.delegationProgram.payload.tokenPower

            distributeProgram(userProfile.tokenPowerSwitch.delegationProgram)
        }

        function resetProgram(node) {
            if (node === undefined) { return }
            if (node.payload === undefined) { return }
            node.payload.delegationProgram = {
                programPower: 0,
                ownPower: 0
            }
            let schemaDocument = getSchemaDocument(node)
            if (schemaDocument === undefined) { return }

            if (schemaDocument.childrenNodesProperties !== undefined) {
                for (let i = 0; i < schemaDocument.childrenNodesProperties.length; i++) {
                    let property = schemaDocument.childrenNodesProperties[i]

                    if (node.type === 'User Profile' && property.name !== "votingProgram") { continue }

                    switch (property.type) {
                        case 'node': {
                            if (node.type === 'User Profile' && property.name === "votingProgram") {
                                let childNode = node[property.name]
                                resetProgram(childNode)
                            }
                        }
                            break
                        case 'array': {
                            let propertyArray = node[property.name]
                            if (propertyArray !== undefined) {
                                for (let m = 0; m < propertyArray.length; m++) {
                                    let childNode = propertyArray[m]
                                    resetProgram(childNode)
                                }
                            }
                            break
                        }
                    }
                }
            }
        }

        function distributeProgram(programNode) {
            if (programNode.payload === undefined) { return }

            /*
            Here we will convert Token Power into programPower. 
            As per system rules programPower = tokensPower
            */
            let programPower = programNode.payload.tokenPower
            /*
            The Own Power is the power generated by the same User Profile tokens, not inherited from others.
            */
            programNode.payload.delegationProgram.ownPower = programPower
            distributeProgramPower(programNode, programPower)
        }

        function distributeProgramPower(node, programPower, percentage) {
            if (node === undefined) { return }
            if (node.payload === undefined) { return }
            if (node.payload.delegationProgram === undefined) { return }

            node.payload.delegationProgram.programPower = node.payload.delegationProgram.programPower + programPower
            drawPower(node, node.payload.delegationProgram.programPower, percentage)
            /*
            When we reach certain node types, we will halt the distribution, because these are targets for 
            delegate power.
            */
            if (
                node.type === 'User Profile'
            ) { return }
            /*
            If there is a reference parent defined, this means that the delegate power is 
            transfered to it and not distributed among children.
            */
            if (
                node.payload.referenceParent !== undefined &&
                node.type === 'User Delegate'
            ) {
                distributeProgramPower(node.payload.referenceParent, programPower)
                return
            }
            /*
            If there is no reference parent we will redistribute delegate power among children.
            */
            let schemaDocument = getSchemaDocument(node)
            if (schemaDocument === undefined) { return }

            if (schemaDocument.childrenNodesProperties !== undefined) {
                /*
                Before distributing the delegate power, we will calculate how the power 
                is going to be switched between all nodes. The first pass is about
                scanning all sibling nodes to see which ones have a percentage defined
                at their config, and check that all percentages don't add more than 100.
                */
                let totalPercentage = 0
                let totalNodesWithoutPercentage = 0
                for (let i = 0; i < schemaDocument.childrenNodesProperties.length; i++) {
                    let property = schemaDocument.childrenNodesProperties[i]

                    switch (property.type) {
                        case 'node': {
                            let childNode = node[property.name]
                            if (childNode === undefined) { continue }
                            if (childNode.type === 'Tokens Bonus') { continue }
                            let percentage = UI.projects.foundations.utilities.nodeConfig.loadConfigProperty(childNode.payload, 'percentage')
                            if (percentage !== undefined && isNaN(percentage) !== true) {
                                totalPercentage = totalPercentage + percentage
                            } else {
                                totalNodesWithoutPercentage++
                            }
                        }
                            break
                        case 'array': {
                            let propertyArray = node[property.name]
                            if (propertyArray !== undefined) {
                                for (let m = 0; m < propertyArray.length; m++) {
                                    let childNode = propertyArray[m]
                                    if (childNode === undefined) { continue }
                                    if (childNode.type === 'Tokens Bonus') { continue }
                                    let percentage = UI.projects.foundations.utilities.nodeConfig.loadConfigProperty(childNode.payload, 'percentage')
                                    if (percentage !== undefined && isNaN(percentage) !== true) {
                                        totalPercentage = totalPercentage + percentage
                                    } else {
                                        totalNodesWithoutPercentage++
                                    }
                                }
                            }
                            break
                        }
                    }
                }
                if (totalPercentage > 100) {
                    node.payload.uiObject.setErrorMessage('Delegate Power Switching Error. Total Percentage of children nodes is grater that 100.')
                    return
                }
                let defaultPercentage = 0
                if (totalNodesWithoutPercentage > 0) {
                    defaultPercentage = (100 - totalPercentage) / totalNodesWithoutPercentage
                }
                /*
                Here we do the actual distribution.
                */
                for (let i = 0; i < schemaDocument.childrenNodesProperties.length; i++) {
                    let property = schemaDocument.childrenNodesProperties[i]

                    switch (property.type) {
                        case 'node': {
                            let childNode = node[property.name]
                            if (childNode === undefined) { continue }
                            if (childNode.type === 'Tokens Bonus') { continue }
                            let percentage = UI.projects.foundations.utilities.nodeConfig.loadConfigProperty(childNode.payload, 'percentage')
                            if (percentage === undefined || isNaN(percentage) === true) {
                                percentage = defaultPercentage
                            }
                            distributeProgramPower(childNode, programPower * percentage / 100, percentage)
                        }
                            break
                        case 'array': {
                            let propertyArray = node[property.name]
                            if (propertyArray !== undefined) {
                                for (let m = 0; m < propertyArray.length; m++) {
                                    let childNode = propertyArray[m]
                                    if (childNode === undefined) { continue }
                                    if (childNode.type === 'Tokens Bonus') { continue }
                                    let percentage = UI.projects.foundations.utilities.nodeConfig.loadConfigProperty(childNode.payload, 'percentage')
                                    if (percentage === undefined || isNaN(percentage) === true) {
                                        percentage = defaultPercentage
                                    }
                                    distributeProgramPower(childNode, programPower * percentage / 100, percentage)
                                }
                            }
                            break
                        }
                    }
                }
            }
        }

        function drawPower(node, programPower, percentage) {

            if (node.payload !== undefined) {

                if (node.type === 'Delegation Program') {
                    drawProgram(node)

                    if (percentage !== undefined) {
                        node.payload.uiObject.setPercentage(percentage.toFixed(2))
                    }
                    return
                }
                if (node.type === 'User Delegate') {
                    drawUserNode(node, programPower, percentage)
                    return
                }
                if (node.type === 'Delegate Power Switch') {
                    node.payload.uiObject.valueAngleOffset = 180
                    node.payload.uiObject.valueAtAngle = true
                    node.payload.uiObject.percentageAngleOffset = 180
                    node.payload.uiObject.percentageAtAngle = true
                    let powerType = 'Delegate Power'

                    const programPowerText = parseFloat(programPower.toFixed(2)).toLocaleString('en') + ' ' + powerType
                    node.payload.uiObject.setValue(programPowerText)

                    if (percentage !== undefined) {
                        node.payload.uiObject.setPercentage(percentage.toFixed(2))
                    }
                }
            }

            function drawUserNode(node, programPower, percentage) {
                if (node.payload !== undefined) {
    
                    const outgoingPowerText = parseFloat(programPower.toFixed(2)).toLocaleString('en') 
    
                    node.payload.uiObject.valueAngleOffset = 180
                    node.payload.uiObject.valueAtAngle = true
    
                    node.payload.uiObject.setValue(outgoingPowerText + ' Delegate Power')
    
                    node.payload.uiObject.percentageAngleOffset = 180
                    node.payload.uiObject.percentageAtAngle = true
    
                    node.payload.uiObject.setPercentage(percentage)
    
                    if (node.payload.referenceParent !== undefined) {
                        node.payload.uiObject.statusAngleOffset = 0
                        node.payload.uiObject.statusAtAngle = true
        
                        node.payload.uiObject.setStatus(outgoingPowerText + ' ' + ' Outgoing Power')
                    }
                }
            }

            function drawProgram(node) {
                if (node.payload !== undefined) {

                    const ownPowerText = parseFloat(node.payload.delegationProgram.ownPower.toFixed(2)).toLocaleString('en')

                    node.payload.uiObject.statusAngleOffset = 0
                    node.payload.uiObject.statusAtAngle = false

                    node.payload.uiObject.setStatus(ownPowerText + ' Delegate Power')
                }
            }
        }
    }
}