declare module "hiot" {
  import { KafkaBroker } from "hiot-kafka-broker";
  import { Db } from "mongodb";
  import { Server } from "restify";

  export class Locator {
    db: Db;
    broker: KafkaBroker;
    api: Server;

    private constructor();
  }
}

declare module "hiot-app" {
  import * as Logger from "bunyan";
  import { KafkaBuilder } from "hiot-kafka";
  import { MongoDbBuilder } from "hiot-mongodb";
  import { Locator } from "hiot";

  export let mongodb: () => MongoDbBuilder;
  export let kafka: () => KafkaBuilder;
  export let redis: () => any;
  export let connectToAdditionalDb: (locatorKey: string) => any;

  type WaitForConnectionOptions = {
    host?: string;
    server?: string;
    port: number | string;
    [x: string]: any;
  };

  function waitFor(): WaitForBuilder;

  export class WaitForBuilder {
    options: {
      connections: any[];
    };
    connection(options: WaitForConnectionOptions): WaitForBuilder;
    build(): (locator: Locator) => any;

    private constructor();
  }

  function shutdown(): ShutdownBuilder;

  export class ShutdownBuilder {
    options: {
      close: () => any;
      logger: {
        error: (...data: any[]) => void;
      };
    };
    close(close: Function): ShutdownBuilder;
    logger(logger: Logger): ShutdownBuilder;
    build(): (locator: Locator) => Locator;

    private constructor();
  }

  type StartAppOptions = {
    logger: Logger;
    onUncaughtException: Function;
    handleException: Function;
    dependencies?: ("mongodb" | "kafka" | "redis")[];
    aliveFilePeriod?: number;
  };

  function startApp(options: StartAppOptions): Promise<Locator>;

  function failed(logger: Logger): (reason: string) => void;
}

declare module "hiot-app/debug" {
  import { Locator } from "hiot";

  function debug(): (...args: any[]) => any;

  export = debug;
}

declare module "hiot-app/health" {
  import { Locator } from "hiot-app/locator";
  import restify from "restify";

  type DefineRoutesOptions = {
    prefix: string;
    readiness?: { dependencies: ("mongodb" | "kafka" | "redis")[] };
    liveness?: { dependencies: ("mongodb" | "kafka" | "redis")[] };
  };

  type RestifyHandlers = {
    defineRoutes: (api: restify.Server, locator: Locator, options: DefineRoutesOptions) => void;
  };

  export const restifyHandlers: RestifyHandlers;
}

declare module "hiot-kafka-broker" {
  import * as Logger from "bunyan";

  export type ConnectionOptions = {
    logger: Logger;
    createTopics: boolean;
    clientId: string;
    connectionString: string;
    groupId: string;
    startingOffset: number;
  };

  export type Envelope<
    T = {
      value: {
        timestamp: number;
        correlationId: string;
        [x: string]: any;
      };
      key?: string;
    }
  > = {
    /** Exists if the message was received from Kafka, should not be set when sending a message */
    ack?: (...args) => void;
    /** Exists if the message was received from Kafka, should not be set when sending a message */
    reject?: (...args) => void;
    topic: string;
    partition: number;
    message: T;
  };

  export class KafkaBroker {
    handlers: { [topic: string]: Function };
    connected: boolean;
    producer: {
      clientId: string;
      connectionString: string;
      logger: {
        logLevel: 4;
        logFunction: (...args: any[]) => void;
      };
      retries: {
        attempts: 3;
        delay: 200;
      };
    };

    private constructor();

    connect(options: ConnectionOptions): Promise<any>;

    send(envelope: Envelope): Promise<void>;

    sendBatch(envelopes: Envelope[]): Promise<void>;

    consume(topic: string, handler: (...args: any[]) => any): Promise<void>;

    close(): void;

    refresh(): void;
  }
}

declare module "hiot-kafka" {
  import { KafkaBroker, Envelope } from "hiot-kafka-broker";
  import * as Logger from "bunyan";
  import { Locator } from "hiot-app/locator";

  export = () => new KafkaBuilder();

  export const broker: KafkaBroker;

  export const createTopics: (client: any, topics: any) => any;

  export const envelope: { parse: (consumer: any, payload: any, topic: any, partition: any, logger: Logger) => any };

  export const logParser: (logger: Logger) => (...args: any[]) => void;

  export class KafkaBuilder {
    options: {
      server: string;
      port: number;
      groupId: string;
      clientId: string;
      createTopics: boolean;
      logger: {
        error: (...data: any[]) => void;
        debug: (...data: any[]) => void;
        info: (...data: any[]) => void;
        trace: (...data: any[]) => void;
        warn: (...data: any[]) => void;
      };
      handlers: () => void;
    };
    logger(logger: Logger): KafkaBuilder;
    handlers(handlers: string[] | (() => any)): KafkaBuilder;
    config(config: {
      logger?: any;
      connectionString?: string;
      server?: string;
      port?: number | string;
      groupId?: string;
      clientId?: string;
    }): KafkaBuilder;
    build(): (locator: Locator) => Locator;

    private constructor();
  }
}

declare module "hiot-kafka/handleEnvelope" {
  function handleEnvelope<T = any>(
    callback: (envelope: Envelope, options: T) => any,
    options: T,
    logger: Logger,
    handleError: (
      err: any,
      data: {
        extra: {
          envelope: Envelope;
        };
      }
    ) => {}
  ): Promise<void>;

  export = handleEnvelope;
}

declare module "hiot-app/locator" {
  import { KafkaBroker } from "hiot-kafka-broker";
  import { Db } from "mongodb";

  const db: Db;
  const broker: KafkaBroker;
  const api: any;

  export = { db, broker, api };
}

declare module "hiot-mongodb" {
  import { ClassLikeDeclaration } from "typescript";
  import { ReqUser } from "../lib/models/ReqUser";
  import { Collection, Db } from "mongodb";
  import { KafkaBroker } from "hiot-kafka-broker";
  import * as Logger from "bunyan";
  import { Locator } from "hiot-app/locator";

  export = () => new MongoDbBuilder();
  export const createTopics: (client: any, topics: any) => any;
  export const envelope: { parse: (consumer: any, payload: any, topic: any, partition: any, logger: Logger) => any };
  export const logParser: (logger: Logger) => (...args: any[]) => void;

  export const test = {
    insert: (locator: Locator, context: any) => new Promise<void>(),
  };

  export class MongoDbBuilder {
    options: {
      server: string;
      port: number;
      groupId: string;
      clientId: string;
      createTopics: boolean;
      logger: {
        error: (...data: any[]) => void;
        debug: (...data: any[]) => void;
        info: (...data: any[]) => void;
        trace: (...data: any[]) => void;
        warn: (...data: any[]) => void;
      };
      handlers: () => void;
    };
    logger(logger: Logger): MongoDbBuilder;
    handlers(handlers: any): MongoDbBuilder;
    config(config: { host: string; port: number | string; database: string; replicaSet: string }): MongoDbBuilder;
    build(): (locator: Locator) => Locator;

    private constructor();
  }

  export enum ACL {
    Write = "write",
    Delete = "delete",
    Read = "read",
  }

  export class Repository<T> {
    name: string;
    Type: T;
    locator: Locator;

    /**
     * @param name mongodb collection name
     * @param Type the (js) class definition for documents
     * @param locator mongodb connection
     */
    constructor(name: string, Type: any, locator: Locator);

    public getById(id: string, user?: ReqUser): Promise<T | undefined>;

    public getAll(user: ReqUser | undefined, query: any): Promise<T[]>;

    public getAllByPaging(query: any, sorting: any, size: number, page: number, user?: ReqUser): Promise<T[]>;

    public getTotalCount(query: any): Promise<number>;

    public patch(id: string, patch: any): Promise<T>;

    public update(id: string, updateData: any, user?: ReqUser): Promise<T>;

    public save(data: T, user?: ReqUser): Promise<T>;

    public remove(id: string, user?: ReqUser): Promise<number>;

    public collection(): Collection<T>;
  }

  export const queryBuilder: {
    findFilter(user: ReqUser, search: any): any;

    findOneFilter(id: string, user: ReqUser, acl: string): { $and: any[] };
  };
}

declare module "hiot-app/httpClient" {
  // import { AxiosInstance } from "axios";

  type HttpForOptions = {
    config: any;
    apiUser?: string;
    correlationId?: string;
  };

  function httpFor(options: HttpForOptions): any;

  function handleResponse<T = any>(promise: PromiseLike, successStatus?: number): Promise<T>;

  function fetchPaginatedResponse<T = any>(http: any, urlBasePath: string, pageSize: number = 50): Promise<T>;
}

declare module "hiot-app/setupNock" {
  import nock from "nock";

  function setupNock(): typeof nock;

  export = setupNock;
}

declare module "hiot-app/generateHandleException" {
  type Package = {
    name: string;
    version: number;
    [x: string]: any;
  };

  type ProcessEnv = {
    SENTRY_ENVIRONMENT?: string;
    API_HOST?: string;
  };

  type GenerateHandleExceptionOptions = {
    processEnv: any;
    pkg: Package;
    sentryRelease?: any;
  };

  function generateHandleException(options: GenerateHandleExceptionOptions): (err: any, metadata?: any) => any;

  export = generateHandleException;
}