function newConditionEditor () {
  const MODULE_NAME = 'Condition Editor'

  let thisObject = {
    isVisibleFunction: undefined,
    visible: false,
    imagePathOK: undefined,
    imagePathNOT_OK: undefined,
    rawRadius: undefined,
    targetRadius: undefined,
    currentRadius: undefined,
    container: undefined,
    payload: undefined,
    deactivate: deactivate,
    activate: activate,
    physics: physics,
    drawBackground: drawBackground,
    drawForeground: drawForeground,
    getContainer: getContainer,
    finalize: finalize,
    initialize: initialize
  }

  thisObject.container = newContainer()
  thisObject.container.initialize(MODULE_NAME)
  thisObject.container.isClickeable = false
  thisObject.container.isDraggeable = false
  thisObject.container.detectMouseOver = false
  thisObject.container.frame.radius = 0
  thisObject.container.frame.position.x = 0
  thisObject.container.frame.position.y = 0

  let isMouseOver = false
  let operationPicker
  let operatorA
  let operatorB

  return thisObject

  function finalize () {
    thisObject.container.finalize()
    thisObject.container = undefined
    thisObject.payload = undefined
    thisObject.isVisibleFunction = undefined

    operationPicker = undefined
    operatorA = undefined
    operatorB = undefined
  }

  function initialize () {

  }

  function deactivate () {
    convertToCode()
    finalizePickers()

    if (thisObject.visible === true) {
      thisObject.visible = false
    }
    EDITOR_ON_FOCUS = false
  }

  function convertToCode () {
    if (operatorA === undefined || operatorB === undefined || operationPicker === undefined) { return }

    // chart.at01hs.bollingerSubChannel.previous.previous.slope=== "Extreme"
    let code = ''

    code = code + 'chart.at' + operatorA.timeFramePicker.getValue().replace('-', '')
    code = code + '.' + operatorA.productPicker.getValue()
    code = code + '.' + operatorA.propertyPicker.getValue()

    switch (operationPicker.getValue()) {
      case 'Greater Than': {
        code = code + ' > '
        break
      }
      case 'Less Than': {
        code = code + ' < '
        break
      }
      case 'Greater or Equal Than': {
        code = code + ' >= '
        break
      }
      case 'Less or Equal Than': {
        code = code + ' <= '
        break
      }
      case 'Equal To': {
        code = code + ' === '
        break
      }
    }

    if (operationPicker.getValue() === 'Equal To') {
      code = code + '"' + operatorA.valuePicker.getValue() + '"'
    } else {
      code = code + 'chart.at' + operatorB.timeFramePicker.getValue().replace('-', '')
      code = code + '.' + operatorB.productPicker.getValue()
      code = code + '.' + operatorB.propertyPicker.getValue()
    }

    thisObject.payload.node.code = code
  }

  function activate (payload) {
    thisObject.visible = true
    thisObject.payload = payload
    thisObject.rawRadius = 8
    thisObject.targetRadius = thisObject.container.frame.radius
    thisObject.currentRadius = 0
    thisObject.payload.uiObject.setErrorMessage('', 0)

    operatorA = {}
    operatorB = {}
    scanDataMines()
    initializePickers()
    EDITOR_ON_FOCUS = true
  }

  function scanDataMines () {
    let selector = {}

    let workspace = canvas.designSpace.workspace.workspaceNode

    for (let i = 0; i < workspace.rootNodes.length; i++) {
      let rootNode = workspace.rootNodes[i]
      if (rootNode.type !== 'Data Mine') { continue }
      let dataMine = rootNode
      let dataMineName = loadPropertyFromNodeConfig(dataMine.payload, 'codeName')
      selector[dataMineName] = {}
      let bots = dataMine.sensorBots.concat(dataMine.indicatorBots)
      for (let j = 0; j < bots.length; j++) {
        let bot = bots[j]
        let botName = loadPropertyFromNodeConfig(bot.payload, 'codeName')
        let selectorDataMine = selector[dataMineName]
        selectorDataMine[botName] = {}
        for (let k = 0; k < bot.products.length; k++) {
          let product = bot.products[k]
          let productName = loadPropertyFromNodeConfig(product.payload, 'singularVariableName')
          if (productName === undefined) { continue }
          let selectorProduct = selectorDataMine[botName]
          selectorProduct[productName] = {
            properties: {}
          }
          if (product.record === undefined) { continue }
          for (let m = 0; m < product.record.properties.length; m++) {
            let property = product.record.properties[m]
            let propertyName = loadPropertyFromNodeConfig(property.payload, 'codeName')
            let selectorProperty = selectorProduct[productName]
            selectorProperty = selectorProperty.properties
            selectorProperty[propertyName] = {}
            let possibleValues = loadPropertyFromNodeConfig(property.payload, 'possibleValues')
            if (possibleValues === undefined) { possibleValues = [] }
            let selectorPossibleValue = selectorProperty[propertyName]
            selectorPossibleValue.possibleValues = possibleValues
          }
          let allPossibleTimeFrames = []
          for (let m = 0; m < product.datasets.length; m++) {
            let dataset = product.datasets[m]
            let validTimeFrames = loadPropertyFromNodeConfig(dataset.payload, 'validTimeFrames')
            if (validTimeFrames !== undefined) {
              allPossibleTimeFrames = allPossibleTimeFrames.concat(validTimeFrames)
            }
          }
          let selectorValidTimeFrames = selectorProduct[productName]
          selectorValidTimeFrames.validTimeFrames = allPossibleTimeFrames

          let productKeys = Object.keys(selectorProduct[productName])
          if (productKeys.length === 0) {
            selectorProduct[productName] = undefined
          }
        }
        let botKeys = Object.keys(selectorDataMine[botName])
        if (botKeys.length === 0) {
          selectorDataMine[botName] = undefined
        }
      }
      let dataMineKeys = Object.keys(selector[dataMineName])
      if (dataMineKeys.length === 0) {
        selector[dataMineName] = undefined
      }
    }
    operatorA.selector = JSON.parse(JSON.stringify(selector))
    operatorB.selector = JSON.parse(JSON.stringify(selector))
  }

  function initializePickers () {
    initializeOperator(operatorA, -1)
    initializeOperator(operatorB, 1)

    operationPicker = newPicker()
    operationPicker.name = 'Data Mine'
    operationPicker.container.connectToParent(thisObject.container)
    operationPicker.container.frame.position.x = 0 - operationPicker.container.frame.width / 2
    operationPicker.container.frame.position.y = 0 - operationPicker.container.frame.height / 2
    current = ['Greater Than', 'Less Than', 'Greater or Equal Than', 'Less or Equal Than', 'Equal To']
    operationPicker.initialize(current, current)

    operationPicker.eventSuscriptionId = operationPicker.container.eventHandler.listenToEvent('onParentChanged', onParentChanged)
  }

  function initializeOperator (operator, ySign) {
    let properties
    let parent
    let current

    operator.dataMinePicker = newPicker()
    operator.dataMinePicker.name = 'Data Mine'
    operator.dataMinePicker.container.connectToParent(thisObject.container)
    operator.dataMinePicker.container.frame.position.x = 0 - operator.dataMinePicker.container.frame.width / 2 - operator.dataMinePicker.container.frame.width * 2
    operator.dataMinePicker.container.frame.position.y = 0 - operator.dataMinePicker.container.frame.height / 2 + operator.dataMinePicker.container.frame.height * ySign
    current = operator.selector
    properties = Object.keys(current)
    operator.dataMinePicker.initialize(properties, current)
    parent = current
    operator.dataMinePicker.visible = true

    operator.botPicker = newPicker()
    operator.botPicker.name = 'Bot'
    operator.botPicker.container.connectToParent(thisObject.container)
    operator.botPicker.container.frame.position.x = 0 - operator.botPicker.container.frame.width / 2 - operator.botPicker.container.frame.width * 1
    operator.botPicker.container.frame.position.y = 0 - operator.botPicker.container.frame.height / 2 + operator.dataMinePicker.container.frame.height * ySign
    current = parent[properties[0]]
    properties = Object.keys(current)
    operator.botPicker.initialize(properties, current, parent)
    parent = current
    operator.botPicker.visible = true

    operator.productPicker = newPicker()
    operator.productPicker.name = 'Product'
    operator.productPicker.container.connectToParent(thisObject.container)
    operator.productPicker.container.frame.position.x = 0 - operator.productPicker.container.frame.width / 2 - operator.productPicker.container.frame.width * 0
    operator.productPicker.container.frame.position.y = 0 - operator.productPicker.container.frame.height / 2 + operator.dataMinePicker.container.frame.height * ySign
    current = parent[properties[0]]
    properties = Object.keys(current)
    operator.productPicker.initialize(properties, current, parent)
    parent = current
    operator.productPicker.visible = true

    let productParent = parent
    let productProperties = properties

    operator.propertyPicker = newPicker()
    operator.propertyPicker.name = 'Property'
    operator.propertyPicker.container.connectToParent(thisObject.container)
    operator.propertyPicker.container.frame.position.x = 0 - operator.propertyPicker.container.frame.width / 2 + operator.propertyPicker.container.frame.width * 1
    operator.propertyPicker.container.frame.position.y = 0 - operator.propertyPicker.container.frame.height / 2 + operator.dataMinePicker.container.frame.height * ySign
    current = productParent[productProperties[0]]
    current = current.properties
    properties = Object.keys(current)
    operator.propertyPicker.initialize(properties, current, productParent, 'properties')
    parent = current
    operator.propertyPicker.visible = true

    operator.valuePicker = newPicker()
    operator.valuePicker.name = 'Value'
    operator.valuePicker.container.connectToParent(thisObject.container)
    operator.valuePicker.container.frame.position.x = 0 - operator.valuePicker.container.frame.width / 2
    operator.valuePicker.container.frame.position.y = 0 - operator.valuePicker.container.frame.height / 2 + operator.valuePicker.container.frame.height * 1
    current = parent[properties[0]]
    properties = current.possibleValues
    operator.valuePicker.initialize(properties, current, parent, 'possibleValues')
    parent = current
    operator.valuePicker.visible = false

    operator.timeFramePicker = newPicker()
    operator.timeFramePicker.name = 'Time Frame'
    operator.timeFramePicker.container.connectToParent(thisObject.container)
    operator.timeFramePicker.container.frame.position.x = 0 - operator.timeFramePicker.container.frame.width / 2 + operator.timeFramePicker.container.frame.width * 2
    operator.timeFramePicker.container.frame.position.y = 0 - operator.timeFramePicker.container.frame.height / 2 + operator.timeFramePicker.container.frame.height * ySign
    current = productParent[productProperties[0]]
    properties = current.validTimeFrames
    operator.timeFramePicker.initialize(properties, current, productParent, 'validTimeFrames')
    parent = current
    operator.timeFramePicker.visible = true

    operator.botPicker.eventSuscriptionId = operator.dataMinePicker.container.eventHandler.listenToEvent('onParentChanged', operator.botPicker.onParentChanged)
    operator.productPicker.eventSuscriptionId = operator.botPicker.container.eventHandler.listenToEvent('onParentChanged', operator.productPicker.onParentChanged)
    operator.propertyPicker.eventSuscriptionId = operator.productPicker.container.eventHandler.listenToEvent('onParentChanged', operator.propertyPicker.onParentChanged)
    operator.valuePicker.eventSuscriptionId = operator.propertyPicker.container.eventHandler.listenToEvent('onParentChanged', operator.valuePicker.onParentChanged)
    operator.timeFramePicker.eventSuscriptionId = operator.productPicker.container.eventHandler.listenToEvent('onParentChanged', operator.timeFramePicker.onParentChanged)
  }

  function finalizePickers () {
    finalizeOperator(operatorA)
    finalizeOperator(operatorB)

    operatorA = undefined
    operatorB = undefined

    if (operationPicker !== undefined) {
      operationPicker.container.eventHandler.stopListening(operationPicker.eventSuscriptionId)
      operationPicker.finalize()
      operationPicker = undefined
    }
  }

  function finalizeOperator (operator) {
    if (operator === undefined) { return }
    if (operator.dataMinePicker !== undefined) {
      operator.dataMinePicker.container.eventHandler.stopListening(operator.botPicker.eventSuscriptionId)
      operator.dataMinePicker.finalize()
      operator.dataMinePicker = undefined
    }

    if (operator.botPicker !== undefined) {
      operator.botPicker.container.eventHandler.stopListening(operator.productPicker.eventSuscriptionId)
      operator.botPicker.finalize()
      operator.botPicker = undefined
    }

    if (operator.productPicker !== undefined) {
      operator.productPicker.container.eventHandler.stopListening(operator.propertyPicker.eventSuscriptionId)
      operator.productPicker.container.eventHandler.stopListening(operator.timeFramePicker.eventSuscriptionId)
      operator.productPicker.finalize()
      operator.productPicker = undefined
    }

    if (operator.propertyPicker !== undefined) {
      operator.propertyPicker.container.eventHandler.stopListening(operator.valuePicker.eventSuscriptionId)
      operator.propertyPicker.finalize()
      operator.propertyPicker = undefined
    }

    if (operator.valuePicker !== undefined) {
      operator.valuePicker.finalize()
      operator.valuePicker = undefined
    }

    if (operator.timeFramePicker !== undefined) {
      operator.timeFramePicker.finalize()
      operator.timeFramePicker = undefined
    }
  }

  function onParentChanged (event) {
    if (event.selected === 4) { // this means Equal To
      operatorA.valuePicker.visible = true
      operatorB.dataMinePicker.visible = false
      operatorB.botPicker.visible = false
      operatorB.productPicker.visible = false
      operatorB.propertyPicker.visible = false
      operatorB.timeFramePicker.visible = false
    } else {
      operatorA.valuePicker.visible = false
      operatorB.dataMinePicker.visible = true
      operatorB.botPicker.visible = true
      operatorB.productPicker.visible = true
      operatorB.propertyPicker.visible = true
      operatorB.timeFramePicker.visible = true
    }
  }

  function getContainer (point) {
    let container
    if (thisObject.visible === true) {
      if (operationPicker !== undefined) {
        container = operationPicker.getContainer(point)
        if (container !== undefined) { return container }
      }

      if (operatorA !== undefined) {
        if (operatorA.dataMinePicker !== undefined) {
          if (operatorA.dataMinePicker.visible === true) {
            container = operatorA.dataMinePicker.getContainer(point)
            if (container !== undefined) { return container }
          }
        }

        if (operatorA.botPicker !== undefined) {
          if (operatorA.botPicker.visible === true) {
            container = operatorA.botPicker.getContainer(point)
            if (container !== undefined) { return container }
          }
        }

        if (operatorA.productPicker !== undefined) {
          if (operatorA.productPicker.visible === true) {
            container = operatorA.productPicker.getContainer(point)
            if (container !== undefined) { return container }
          }
        }

        if (operatorA.propertyPicker !== undefined) {
          if (operatorA.propertyPicker.visible === true) {
            container = operatorA.propertyPicker.getContainer(point)
            if (container !== undefined) { return container }
          }
        }

        if (operatorA.valuePicker !== undefined) {
          if (operatorA.valuePicker.visible === true) {
            container = operatorA.valuePicker.getContainer(point)
            if (container !== undefined) { return container }
          }
        }

        if (operatorA.timeFramePicker !== undefined) {
          if (operatorA.timeFramePicker.visible === true) {
            container = operatorA.timeFramePicker.getContainer(point)
            if (container !== undefined) { return container }
          }
        }
      }
      if (operatorB !== undefined) {
        if (operatorB.dataMinePicker !== undefined) {
          if (operatorB.dataMinePicker.visible === true) {
            container = operatorB.dataMinePicker.getContainer(point)
            if (container !== undefined) { return container }
          }
        }

        if (operatorB.botPicker !== undefined) {
          if (operatorB.botPicker.visible === true) {
            container = operatorB.botPicker.getContainer(point)
            if (container !== undefined) { return container }
          }
        }

        if (operatorB.productPicker !== undefined) {
          if (operatorB.productPicker.visible === true) {
            container = operatorB.productPicker.getContainer(point)
            if (container !== undefined) { return container }
          }
        }

        if (operatorB.propertyPicker !== undefined) {
          if (operatorB.propertyPicker.visible === true) {
            container = operatorB.propertyPicker.getContainer(point)
            if (container !== undefined) { return container }
          }
        }

        if (operatorB.valuePicker !== undefined) {
          if (operatorB.valuePicker.visible === true) {
            container = operatorB.valuePicker.getContainer(point)
            if (container !== undefined) { return container }
          }
        }

        if (operatorB.timeFramePicker !== undefined) {
          if (operatorB.timeFramePicker.visible === true) {
            container = operatorB.timeFramePicker.getContainer(point)
            if (container !== undefined) { return container }
          }
        }
      }

      if (thisObject.container.frame.isThisPointHere(point, true, false) === true) {
        return thisObject.container
      } else {
        return undefined
      }
    }
  }

  function physics () {
    thisObjectphysics()
    operatorsPhysics(operatorA)
    operatorsPhysics(operatorB)

    if (operationPicker !== undefined) {
      operationPicker.physics()
    }
  }

  function selectionPhysics () {

  }

  function operatorsPhysics (operator) {
    if (operator === undefined) { return }

    if (operator.dataMinePicker !== undefined) {
      operator.dataMinePicker.physics()
    }

    if (operator.botPicker !== undefined) {
      operator.botPicker.physics()
    }

    if (operator.productPicker !== undefined) {
      operator.productPicker.physics()
    }

    if (operator.propertyPicker !== undefined) {
      operator.propertyPicker.physics()
    }

    if (operator.valuePicker !== undefined) {
      operator.valuePicker.physics()
    }

    if (operator.timeFramePicker !== undefined) {
      operator.timeFramePicker.physics()
    }
  }

  function thisObjectphysics () {
    if (Math.abs(thisObject.currentRadius - thisObject.targetRadius) >= 0.5) {
      if (thisObject.currentRadius < thisObject.targetRadius) {
        thisObject.currentRadius = thisObject.currentRadius + 0.5
      } else {
        thisObject.currentRadius = thisObject.currentRadius - 0.5
      }
    }

    thisObject.container.frame.position.x = 0
    thisObject.container.frame.position.y = 0

    thisObject.container.frame.width = thisObject.container.frame.radius * 1 * 2 * 4
    thisObject.container.frame.height = thisObject.container.frame.radius * 1 * 2 * 4
  }

  function drawBackground () {
    thisObjectDrawBackground()
    childrenDrawBackground()
  }

  function childrenDrawBackground () {
    operatorDrawBackground(operatorA)
    operatorDrawBackground(operatorB)

    if (operationPicker !== undefined) {
      operationPicker.drawBackground()
    }
  }

  function operatorDrawBackground (operator) {
    if (operator === undefined) { return }

    if (operator.dataMinePicker !== undefined) {
      if (operator.dataMinePicker.visible === true) {
        operator.dataMinePicker.drawBackground()
      }
    }

    if (operator.botPicker !== undefined) {
      if (operator.botPicker.visible === true) {
        operator.botPicker.drawBackground()
      }
    }

    if (operator.productPicker !== undefined) {
      if (operator.productPicker.visible === true) {
        operator.productPicker.drawBackground()
      }
    }

    if (operator.propertyPicker !== undefined) {
      if (operator.propertyPicker.visible === true) {
        operator.propertyPicker.drawBackground()
      }
    }

    if (operator.valuePicker !== undefined) {
      if (operator.valuePicker.visible === true) {
        operator.valuePicker.drawBackground()
      }
    }

    if (operator.timeFramePicker !== undefined) {
      if (operator.timeFramePicker.visible === true) {
        operator.timeFramePicker.drawBackground()
      }
    }
  }

  function thisObjectDrawBackground () {
    if (thisObject.visible === true) {
      let position = {
        x: 0,
        y: 0
      }

      position = thisObject.container.frame.frameThisPoint(position)

      let radius = thisObject.container.frame.radius * 2

      if (radius > 0.5) {
        browserCanvasContext.beginPath()
        browserCanvasContext.arc(position.x, position.y, radius * 1.3 + 3, 0, Math.PI * 2, true)
        browserCanvasContext.closePath()
        browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', ' + 1 + ')'
        browserCanvasContext.fill()

        browserCanvasContext.beginPath()
        browserCanvasContext.arc(position.x, position.y, radius * 1.3, 0, Math.PI * 2, true)
        browserCanvasContext.closePath()
        browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.GREY + ', ' + 1 + ')'
        browserCanvasContext.fill()
      }
    }
  }

  function drawForeground () {
    thisObjectDrawForeground()
    childrenDrawForeground()
  }

  function childrenDrawForeground () {
    operatorDrawForeground(operatorA)
    operatorDrawForeground(operatorB)

    if (operationPicker !== undefined) {
      operationPicker.drawForeground()
    }
  }

  function operatorDrawForeground (operator) {
    if (operator === undefined) { return }

    if (operator.dataMinePicker !== undefined) {
      if (operator.dataMinePicker.visible === true) {
        operator.dataMinePicker.drawForeground()
      }
    }

    if (operator.botPicker !== undefined) {
      if (operator.botPicker.visible === true) {
        operator.botPicker.drawForeground()
      }
    }

    if (operator.productPicker !== undefined) {
      if (operator.productPicker.visible === true) {
        operator.productPicker.drawForeground()
      }
    }

    if (operator.propertyPicker !== undefined) {
      if (operator.propertyPicker.visible === true) {
        operator.propertyPicker.drawForeground()
      }
    }

    if (operator.valuePicker !== undefined) {
      if (operator.valuePicker.visible === true) {
        operator.valuePicker.drawForeground()
      }
    }

    if (operator.timeFramePicker !== undefined) {
      if (operator.timeFramePicker.visible === true) {
        operator.timeFramePicker.drawForeground()
      }
    }
  }

  function thisObjectDrawForeground () {
    let iconPosition = {
      x: 0,
      y: thisObject.currentRadius * 1
    }

    iconPosition = thisObject.container.frame.frameThisPoint(iconPosition)

      /* Menu  Item */

    if (thisObject.canDrawIcon === true && thisObject.currentRadius > 1) {
      browserCanvasContext.drawImage(thisObject.icon, iconPosition.x - thisObject.currentRadius, iconPosition.y - thisObject.currentRadius, thisObject.currentRadius * 2, thisObject.currentRadius * 2)

      /* Menu Label */

      let label = 'Code looks good!'
      let labelPoint
      let fontSize = 10

      browserCanvasContext.font = fontSize + 'px ' + UI_FONT.PRIMARY

      if (label !== undefined && thisObject.currentRadius >= thisObject.targetRadius) {
        labelPoint = {
          x: iconPosition.x + thisObject.currentRadius + 10,
          y: iconPosition.y + fontSize * FONT_ASPECT_RATIO
        }

        browserCanvasContext.font = fontSize + 'px ' + UI_FONT.PRIMARY
        browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.WHITE + ', 1)'
        browserCanvasContext.fillText(label, labelPoint.x, labelPoint.y)
      }
    }
  }
}