code.js

import { getAvailiableActuators, getFigureByKey } from './editor';
const DEFAULT_ACTIONS = {
  led: 'turnOff()',
  motor: 'turnOff()',
  servo: 'turnOff()'
};

const TOI_MAPPINGS = {
  led: 'LED',
  distance: 'DSensor',
  motor: 'Motors',
  servo: 'Servos',
  motorsConnector: 'MotorsConnector',
  servosConnector: 'ServosConnector',
  rotatory: 'LineSensors' // this is the line sensor
};

function parseAction(actuator, e) {
  return {
    action: `${actuator.type}${actuator.index}.${e.action}`,
    operation: e.operation.eventType,
    value: e.value
  };
}

function generateHeaders(connectedFigures) {
  return Object.values(connectedFigures)
    .map(fig => {
      const { type, index, port } = fig;
      return `const ${type}${index} = new ${TOI_MAPPINGS[type]}(${port});`;
    })
    .join('\n');
}

function generateActions(actions, connectedFigures) {
  return Object.keys(actions)
    .map(key => {
      const figure = getFigureByKey(key, connectedFigures);
      const { type, index, action } = figure;
      return `${type}${index}.${action};`;
    })
    .join('\n');
}

function generateCaseStatement(eventType, value) {
  switch (eventType) {
    case 'equal':
      return `case (value == ${value}): {`;
    case 'lessThan':
      return `case (value < ${value}): {`;
    case 'moreThan':
      return `case (value > ${value}): {`;
    case 'between':
      return `case (value >= ${value[0]} && value <= ${value[1]}): {`;
    case 'log':
      return 'case (value): {';
    default:
      return '';
  }
}

function generateCaseBody(actions) {
  return [...actions.map(a => `${a.action};`), 'break;', '}'].join('\n');
}

function generateCaseDefaults(sensor, connectedFigures) {
  const defaultActions = Object.keys(sensor).map(key => {
    const actuator = getFigureByKey(key, connectedFigures);
    return `${actuator.type}${actuator.index}.${
      DEFAULT_ACTIONS[actuator.type]
    };`;
  });
  return ['default: {', ...defaultActions, 'break;', '}'].join('\n');
}

function generateCase(actionsValues) {
  return Object.keys(actionsValues)
    .map(key => {
      const actions = actionsValues[key];
      const action = actions[0];
      return [
        generateCaseStatement(action.operation, action.value),
        generateCaseBody(actionsValues[key])
      ].join('\n');
    })
    .join('\n');
}

function generateSwitchBody(actionsValues, sensor, connectedFigures) {
  return [
    'switch (true) {',
    generateCase(actionsValues),
    generateCaseDefaults(sensor, connectedFigures),
    '}'
  ].join('\n');
}

function groupActionsByValue(sensor, connectedFigures) {
  const values = {};
  Object.keys(sensor).forEach(actuatorKey => {
    const actuatorEvents = sensor[actuatorKey];
    actuatorEvents.forEach(e => {
      const actuator = getFigureByKey(actuatorKey, connectedFigures);
      if (values[String(e.value)]) {
        values[String(e.value)].push(parseAction(actuator, e));
      } else {
        values[String(e.value)] = [parseAction(actuator, e)];
      }
    });
  });

  return values;
}

function generateStatement(sensor, connectedFigures) {
  return generateSwitchBody(
    groupActionsByValue(sensor, connectedFigures),
    sensor,
    connectedFigures
  );
}

function generateEvents(events, connectedFigures) {
  return Object.keys(events)
    .map(key => {
      const figure = getFigureByKey(key, connectedFigures);
      const { type, index } = figure;
      const sensor = events[key];

      return `${type}${index}.on('medicion', (value) => {\n ${generateStatement(
        sensor,
        connectedFigures
      )} });`;
    })
    .join('\n');
}

export function generateCode(connectedFigures) {
  const actuators = getAvailiableActuators(connectedFigures);
  const actions = {};
  const events = {};
  actuators.forEach(actuator => {
    // it has more priotity if it has events
    if (actuator.events.length) {
      actuator.events.forEach(e => {
        if (events[e.sensorId]) {
          if (events[e.sensorId][actuator.id]) {
            events[e.sensorId][actuator.id].push(e);
          } else {
            events[e.sensorId] = {
              ...events[e.sensorId],
              [actuator.id]: [e]
            };
          }
        } else {
          events[e.sensorId] = {
            [actuator.id]: [e]
          };
        }
      });
    } else if (actuator.action) {
      actions[actuator.id] = actuator.action;
    }
  });

  return [
    generateHeaders(connectedFigures),
    generateActions(actions, connectedFigures),
    generateEvents(events, connectedFigures)
  ]
    .filter(i => !!i) // filter to remove undefined or null in case actions is null
    .join('\n\n');
}