import {DependencyKey, DependencyRequirement, PropertyDependency} from '../types'
import { Collection } from '../../util'

/**
 * Abstract base class for dependency container factories.
 * @abstract
 */
export abstract class AbstractFactory<T> {
    protected constructor(
        /**
         * Token that was registered for this factory. In most cases, this is the static
         * form of the item that is to be produced by this factory.
         * @var
         * @protected
         */
        protected token: DependencyKey,
    ) {}

    /**
     * Produce an instance of the token.
     * @param {Array} dependencies - the resolved dependencies, in order
     * @param {Array} parameters - the bound constructor parameters, in order
     */
    abstract produce(dependencies: any[], parameters: any[]): T

    /**
     * Should return true if the given identifier matches the token for this factory.
     * @param something
     * @return boolean
     */
    abstract match(something: unknown): boolean

    /**
     * Get the dependency requirements required by this factory's token.
     * @return Collection<DependencyRequirement>
     */
    abstract getDependencyKeys(): Collection<DependencyRequirement>

    /**
     * Get the property dependencies that should be injected to the created instance.
     * @return Collection<PropertyDependency>
     */
    abstract getInjectedProperties(): Collection<PropertyDependency>

    /**
     * Get a human-readable name of the token this factory produces.
     * This is meant for debugging output only.
     */
    public getTokenName(): string {
        if ( typeof this.token === 'string' ) {
            return this.token
        }

        return this.token?.name ?? '(unknown token)'
    }
}