import * as _ from 'lodash';
import 'reflect-metadata';
import { createConnection } from 'typeorm';
import { Dashboard } from '../../entities/dashboard';
import { Sensor } from '../../entities/sensor';

main().then(() => console.log('done'));

async function main() {

  createConnection({
    name: 'dev',
    type: 'mysql',
    host: 'dev.db.n5-nederman.com',
    port: 3306,
    username: 'dbadmin',
    password: 'gUYZ6anpLEF3gksC',
    database: 'iot_test',
    entities: [
      './lib/entities/*.js'
    ],
    migrations: [
      './migration/dev/*.js'
    ],
    cli: {
      migrationsDir: './migration/dev'
    }
  }).then(async (connection) => {
    const dashboardRepository = connection.getRepository(Dashboard);
    const sensorRepository = connection.getRepository(Sensor);

    const dashboards: Dashboard[] = await dashboardRepository.createQueryBuilder('dashboard')
      .leftJoinAndSelect('dashboard.plant', 'plant')
      .leftJoinAndSelect('dashboard.system', 'system')
      // .where('dashboard.dashboardId IN (\'52519425-c793-4405-87a1-0dfbbc507e0d\')')
      .getMany();

    let sensors: Sensor[];
    for (const dashboard of dashboards) {
      const definition = JSON.parse(dashboard.definition);

      if (definition.binding && definition.binding.length !== 0) {
        sensors = await sensorRepository.createQueryBuilder('sensor')
          .leftJoinAndSelect('sensor.metadata', 'metadata')
          .where('sensor.sensorId IN (:sensorIds)')
          .setParameters({ sensorIds: definition.binding })
          .getMany();

        for (const sensor of sensors) {
          if (sensor.metadata && sensor.metadata['label'] !== '') sensor['label'] = sensor.metadata.label;
          else sensor['label'] = sensor.name;
        }

        const updatedDefinition = await updateLayout(definition, sensors);
        dashboard.definition = JSON.stringify(updatedDefinition);
        console.log('dashboard name', dashboard.name);

        await dashboardRepository.save(dashboard);
      }
    }
  }).catch(error => console.log(error));

  async function updateLayout(definition: { [key: string]: any }, sensors: Sensor[]): Promise<any> {

    if (!definition) { return null; }
    for (let i = 0; i < _.get(definition, 'children', definition).length; i++) {

      // / if there are children in the element, check them /;
      if (definition.children) {

        // / if element has other children /;
        if (!_.isEmpty(definition.children[i].children)) {
          updateLayout(definition.children[i], sensors);
        }
      }

      if (definition.children[i]['config']) {
        if (definition.children[i]['component'] !== 'multiLineChart') {
          if (definition.children[i]['binding'] && definition.children[i]['binding'].sensorId && definition.children[i]['layout']) {
            const foundSensor = sensors.find((sensor: Sensor) => sensor.sensorId === definition.children[i]['binding'].sensorId);
            if (foundSensor) {
              definition.children[i]['layout'].label = foundSensor.label || foundSensor.name;
              delete definition.children[i]['layout'].name;
            }
          }
        } else {
          if (definition.children[i]['config'].sensors) {
            definition.children[i]['config'].sensors.map((multiLineSensor: any) => {
              const foundSensor = sensors.find((sensor: Sensor) => sensor.sensorId === multiLineSensor['binding'].sensorId);
              if (multiLineSensor.config) {
                multiLineSensor.config.label = foundSensor.label || foundSensor.name;
              }
            });
          }
        }
      }
    }
    return definition;
  }
}