import { DBCore, Query, Transformer } from "./driver";
import { LogGenerator, Logger, createChildLogger } from "@alchemist/logger";
import { Setup, Teardown } from "@alchemist/common-types";
import {
  DriversDBNotInitializedError,
  DRIVERS_DB_STARTED,
  DRIVERS_DB_SHUTDOWN
} from "@alchemist/resources";
import { DBTransaction } from "./DBTransaction";

interface Options {
  logger: Logger.Logger;
  connectionString: string;
  userName: string;
  password: string;
  isEnterprise?: boolean;
}

export interface DBOptions extends Options {}

export class DB implements LogGenerator, Setup, Teardown {
  private db?: DBCore.v1.Driver;
  private transformer = new Transformer();
  logger: Logger.Logger;
  options: Options;
  constructor(options: Options) {
    this.options = options;
    this.logger = this.createLogger(options.logger);
  }
  createLogger(baseLogger: Logger.Logger) {
    return createChildLogger(baseLogger, "DB");
  }
  get instance() {
    if (this.db) {
      return this.db;
    }

    throw new DriversDBNotInitializedError();
  }
  transaction() {
    return new DBTransaction(this);
  }
  getQueryAndParams(query: Query | string, params?: any) {
    if (query instanceof Query) {
      const { query: q, params: p } = query.buildQueryObject();
      return { query: q, params: Object.assign({}, p, params) };
    }

    return { query, params };
  }
  transformResults<R = any>(result: DBCore.v1.StatementResult) {
    return this.transformer.transformRecords<R>(result.records);
  }
  async runQuery<R = any>(
    query: Query | string,
    params?: any,
    transaction?: DBTransaction,
    logger = this.logger.child({ function: this.runQuery.name })
  ) {
    const { query: q, params: p } = this.getQueryAndParams(query, params);
    logger.debug({
      query: q,
      params: p,
      transaction: transaction && transaction.id
    });
    if (transaction) {
      return this.transformResults(await transaction.run(q, p));
    }

    const session = this.instance.session();
    try {
      return this.transformResults(await session.run(q, p));
    } finally {
      session.close();
    }
  }
  async setup(): Promise<void> {
    const { connectionString, userName, password, isEnterprise } = this.options;
    this.db = DBCore.v1.driver(
      connectionString,
      DBCore.v1.auth.basic(userName, password)
    );
    this.logger.info(
      { connectionString, userName, isEnterprise },
      DRIVERS_DB_STARTED
    );
  }
  private static assertEnv(param: string) {
    const result = process.env[param];
    if (!result) {
      throw new Error(`process.env.${param} not available!`);
    }

    return result;
  }
  static async fromEnv(logger: Logger.Logger) {
    const connectionString = `${DB.assertEnv(
      "NEO4J_PROTOCOL"
    )}://${DB.assertEnv("NEO4J_HOST")}:${DB.assertEnv("NEO4J_PORT")}`;
    const userName = DB.assertEnv("NEO4J_USERNAME");
    const password = DB.assertEnv("NEO4J_PASSWORD");
    const isEnterprise = process.env.NEO4J_ENTERPRISE === "true";
    return new DB({
      logger,
      connectionString,
      userName,
      password,
      isEnterprise
    });
  }
  async teardown(): Promise<void> {
    if (this.db) {
      this.logger.info(DRIVERS_DB_SHUTDOWN);
      this.db.close();
      this.db = undefined;
    }
  }
}