import config from "config";
import "reflect-metadata";
import {
  DataSource,
  DataSourceOptions,
  EntityTarget,
  ObjectLiteral,
  Repository,
} from "typeorm";
import { ORMLogger } from "./utils/ORMLogger";

export const dataSourceOptions: Map<string, DataSourceOptions> = new Map([
  [
    "default",
    {
      type: "mysql",
      host: config.get("dbHost"),
      charset: "utf8mb4_unicode_ci",
      port: config.get("dbPort"),
      username: config.get("dbUser"),
      password: config.get("dbPass"),
      database: config.get("adminDbName"),
      logger: new ORMLogger(),
      acquireTimeout: 50000,
      connectTimeout: 50000,
      logging: process.env.NODE_ENV !== "production",
      migrationsRun: true,
      entities: [__dirname + "/models/admin/*.{js,ts}"],
      migrations: [__dirname + "/migrations/*.{js,ts}"],
      subscribers: [__dirname + "/subscribers/**/*.{js,ts}"],
      bigNumberStrings: true,
    },
  ],
  [
    "mongo-logger",
    {
      type: "mongodb",
      host: config.get("mongoHost"),
      port: config.get("mongoPort"),
      username: config.get("mongoUser"),
      password: config.get("mongoPass"),
      database: config.get("mongoDB"),
      authSource: "admin",
      synchronize: true,
      logging: false,
      useUnifiedTopology: true,
      useNewUrlParser: true,
      entities: [__dirname + "/models/mongo/*.{js,ts}"],
      migrations: [__dirname + "/migrations/*.{js,ts}"],
      subscribers: [__dirname + "/subscribers/*.{js,ts}"],
    },
  ],
  ["companyContext", getCompanyDataSource(config.get("dbName"), true)],
]);

// to be used instead of getConnectionManager()
export class DataSourceManager {
  private static instance: DataSourceManager;
  private dataSources: Map<string, DataSource> = new Map();

  private constructor() {}

  public static getInstance(): DataSourceManager {
    if (!DataSourceManager.instance) {
      DataSourceManager.instance = new DataSourceManager();
    }
    return DataSourceManager.instance;
  }

  public async createDataSource(
    name: string,
    options?: DataSourceOptions
  ): Promise<DataSource> {
    const _options = options || dataSourceOptions.get(name);
    return this.dataSources
      .set(name, await new DataSource(_options).initialize())
      .get(name);
  }

  public getDataSource(dataSourceName: string): DataSource {
    return this.dataSources.get(dataSourceName || "default");
  }

  private map() {
    return Array.from(this.dataSources.values());
  }

  public getActiveDataSources() {
    return this.map().filter((ds: DataSource) => ds.isInitialized);
  }

  public debug() {
    console.log(
      "DataSourceManager.debug",
      this.getActiveDataSources().map((ds: DataSource) => {
        return {
          isInitialized: ds.isInitialized,
          type: ds.options.type,
          dbName: ds.options.database,
        };
      })
    );
  }

  public async destroyDataSources() {
    return Promise.all(
      Array.from(this.dataSources.values()).map((dataStore) =>
        dataStore.destroy()
      )
    )
      .then((data) => {
        console.log(`Destroyed (${data.length}) data source`);
      })
      .catch((errors) => {
        console.log("Error: Destroying DataSources:", errors);
      });
  }
}

export function getCompanyDataSource(
  databaseName: string,
  migrationsRun = true
): DataSourceOptions {
  return {
    type: "mysql",
    charset: "utf8mb4_unicode_ci",
    host: config.get("dbHost"),
    port: Number(config.get("dbPort")),
    username: config.get("dbUser").toString(),
    password: config.get("dbPass").toString(),
    logger: new ORMLogger(),
    database: databaseName,
    acquireTimeout: 50000,
    connectTimeout: 50000,
    logging: process.env.NODE_ENV !== "production",
    entities: [
      __dirname + "/models/*.{js,ts}",
      __dirname + "/modules/**/models/*.{js,ts}",
    ],
    migrations: [__dirname + "/migrations/companyContext/*.{js,ts}"],
    subscribers: [__dirname + "/subscribers/**/*.{js,ts}"],
    migrationsRun,
    bigNumberStrings: true,
  };
}

// HELPER FUNCTIONS FOR BETTER TYPEORM v0.2.x -> v0.3.x UPDATE
// to be used instead of getRepository()
export function getDataRepository<Entity extends ObjectLiteral>(
  entityClass: EntityTarget<Entity>,
  dataSourceName?: string
): Repository<Entity> {
  return DataSourceManager.getInstance()
    .getDataSource(dataSourceName || "default")
    .getRepository(entityClass);
}

// to be used instead of getConnection()
export function getDataSource(dataSourceName?: string): DataSource {
  return DataSourceManager.getInstance().getDataSource(
    dataSourceName || "default"
  );
}

import { DataSource } from 'typeorm';
import { dataSourceOptions } from './data-source';

const adminDataSourceOptions = dataSourceOptions.get('default');

// this file is only for cli migration utils
export default new DataSource(adminDataSourceOptions);

import { DataSource } from 'typeorm';
import { dataSourceOptions } from './data-source';

const companyDataSourceOptions = dataSourceOptions.get('companyContext');

// this file is only for cli migration utils
export default new DataSource(companyDataSourceOptions);