import { Factory } from './Factory'
import { Collection } from '../../util'
import {DependencyRequirement, PropertyDependency} from "../types";

/**
 * Container factory which returns its token as its value, without attempting
 * to instantiate anything. This is used to register already-produced-singletons
 * with the container.
 *
 * @example
 * ```typescript
 * class A {}
 * const exactlyThisInstanceOfA = new A()
 *
 * const fact = new SingletonFactory(A, a)
 *
 * fact.produce([], [])  // => exactlyThisInstanceOfA
 * ```
 *
 * @extends Factory
 */
export default class SingletonFactory extends Factory {
    constructor(
        /**
         * Instantiated value of this factory.
         * @type FunctionConstructor
         */
        protected token: FunctionConstructor,

        /**
         * String name of this singleton identifying it in the container.
         * @type string
         */
        protected key: string,
    ) {
        super(token)
    }

    produce(dependencies: any[], parameters: any[]) {
        return this.token
    }

    match(something: any) {
        return something === this.key
    }

    getDependencyKeys(): Collection<DependencyRequirement> {
        return new Collection<DependencyRequirement>()
    }

    getInjectedProperties(): Collection<PropertyDependency> {
        return new Collection<PropertyDependency>()
    }
}