/* @flow */

type ClassDecorator = <T: Function>(target: T) => T;
type PropertyDecorator = (target: Object, propertyKey: string) => void;
type MethodDecorator = (
  target: Object,
  key: string,
  descriptor: Object
) => Object | void;
type Token = Function | Object | string;
type Definition = Function | [Function] | [Token, Function];
type Provider = {
  /**
   * Register dependency injection bindings in scope of decorated class
   * @param definitions Dependency injection configuration
   * @returns Decorated constructor
   */
  register(...definitions: Definition[]): void;
};
type ProviderMixin<T> = T &
  Provider & {
    contextType: typeof InjectorContext;
    WrappedComponent: T;
  };

declare export var InjectorContext: any;

/**
 * Decorator or HOC that register dependency injection bindings
 * in scope of decorated class
 * @param definitions Dependency injection configuration
 * @returns Decorator or HOC
 */
declare export function provider(
  ...definitions: Definition[]
): <T: Function>(target: T) => ProviderMixin<T>;

/**
 * Decorator that lazily registers class in scope of specified Provider.
 * @param getProvider Lambda function that returns Provider
 * @param biding Dependency injection binding
 * @returns Decorator
 */
declare export function registerIn(
  getProvider: () => Provider,
  biding?: Function
): <T: Function>(target: T) => T;

/**
 * Property decorator that resolves a class instance
 * which registered by some Provider in hierarchy.
 * Instance is cached in Provider that registers it's class.
 * @param token Dependency injection token
 * @returns Property decorator
 */
declare export function inject(token?: Token): PropertyDecorator;
/**
 * Property decorator that resolves a class instance
 * which registered by some Provider in hierarchy.
 * Instance is cached in Provider that registers it's class.
 */
declare export function inject(target: Object, key: string): void;
/**
 * Create a class instance that registered by some Provider in hierarchy.
 * Instance is cached in Provider that registers it's class.
 * @param target The object in which we inject class instance
 * @param token Dependency injection token
 * @returns Resolved class instance
 */
declare export function inject<T>(
  target: Object,
  token: Class<T> | Token
): T;

/**
 * React hook for resolving a class instance that registered by some Provider in hierarchy.
 * Instance is cached in Provider that registers it's class.
 * @param token Dependency injection token
 * @returns Resolved class instance
 */
declare export function useInstance<T>(token: Class<T> | Token): T;

/**
 * React hook for resolving a class instances that registered by some Provider in hierarchy.
 * Instances are cached in Provider that registers it's classes.
 * @param tokens Dependency injection tokens
 * @returns Resolved class instances
 */
declare export function useInstances<T: any[]>(
  ...tokens: $TupleMap<T, <V>(V) => Class<V> | Token>
): T;

/**
 * Bind dependency to specified class.
 * @param cosntructor Constructor
 * @returns Dependency resolver
 */
declare export function toClass(cosntructor: Class<any>): Function;

/**
 * Bind dependency to specified value.
 * @param value Any value
 * @returns Dependency resolver
 */
declare export function toValue(value: any): Function;

/**
 * Bind dependency to specified factory funciton.
 * @param factory Factory
 * @returns Dependency resolver
 */
declare export function toFactory(factory: () => any): Function;
/**
 * Bind dependency to specified factory funciton.
 * @param deps Factory dependencies
 * @param factory Factory
 * @returns Dependency resolver
 */
declare export function toFactory<T: any[]>(
  deps: $TupleMap<T, <V>(V) => Class<V> | Token>,
  factory: (...args: T) => any
): Function;

/**
 * Bind dependency to existing instance located by token.
 * @param token Dependency injection token
 * @returns Dependency resolver
 */
declare export function toExisting(token: Token): Function;

export { inject as Inject, provider as Provider, registerIn as RegisterIn };