import 'reflect-metadata'
import {collect, Collection} from "../../util";
import {
    DependencyKey,
    DependencyRequirement,
    DEPENDENCY_KEYS_METADATA_KEY,
    DEPENDENCY_KEYS_PROPERTY_METADATA_KEY,
    isInstantiable,
    InjectionType,
    DEPENDENCY_KEYS_SERVICE_TYPE_KEY,
    PropertyDependency,
} from "../types";
import {Container} from "../Container";

/**
 * Get a collection of dependency requirements for the given target object.
 * @param {Object} target
 * @return Collection<DependencyRequirement>
 */
function initDependencyMetadata(target: Object): Collection<DependencyRequirement> {
    const paramTypes = Reflect.getMetadata('design:paramtypes', target)
    return collect<DependencyKey>(paramTypes).map<DependencyRequirement>((type, idx) => {
        return {
            paramIndex: idx,
            key: type,
            overridden: false,
        }
    })
}

/**
 * Class decorator that marks a class as injectable. When this is applied, dependency
 * metadata for the constructors params is resolved and stored in metadata.
 * @constructor
 */
export const Injectable = (): ClassDecorator => {
    return (target) => {
        const meta = initDependencyMetadata(target)
        const existing = Reflect.getMetadata(DEPENDENCY_KEYS_METADATA_KEY, target)
        const new_meta = new Collection<DependencyRequirement>()

        if ( existing ) {
            const max_new = meta.max('paramIndex')
            const max_existing = existing.max('paramIndex')
            for ( let i = 0; i <= Math.max(max_new, max_existing); i++ ) {
                const existing_dr = existing.firstWhere('paramIndex', '=', i)
                const new_dr = meta.firstWhere('paramIndex', '=', i)

                if ( existing_dr && !new_dr ) {
                    new_meta.push(existing_dr)
                } else if ( new_dr && !existing_dr ) {
                    new_meta.push(new_dr)
                } else if ( new_dr && existing_dr ) {
                    if ( existing_dr.overridden ) {
                        new_meta.push(existing_dr)
                    } else {
                        new_meta.push(new_dr)
                    }
                }
            }
        } else {
            new_meta.concat(meta)
        }

        Reflect.defineMetadata(DEPENDENCY_KEYS_METADATA_KEY, new_meta, target)
    }
}

/**
 * Mark the given class property to be injected by the container.
 * If a `key` is specified, that DependencyKey will be injected.
 * Otherwise, the DependencyKey is inferred from the type annotation.
 * @param key
 * @constructor
 */
export const Inject = (key?: DependencyKey): PropertyDecorator => {
    return (target, property) => {
        let propertyMetadata = Reflect.getMetadata(DEPENDENCY_KEYS_PROPERTY_METADATA_KEY, target?.constructor || target) as Collection<PropertyDependency>
        if ( !propertyMetadata ) {
            propertyMetadata = new Collection<PropertyDependency>()
            Reflect.defineMetadata(DEPENDENCY_KEYS_PROPERTY_METADATA_KEY, propertyMetadata, target?.constructor || target)
        }

        const type = Reflect.getMetadata('design:type', target, property)
        if ( !key && type ) key = type

        if ( key ) {
            const existing = propertyMetadata.firstWhere('property', '=', property)
            if ( existing ) {
                existing.key = key
            } else {
                propertyMetadata.push({ property, key })
            }
        }

        Reflect.defineMetadata(DEPENDENCY_KEYS_PROPERTY_METADATA_KEY, propertyMetadata, target?.constructor || target)
    }
}

/**
 * Parameter decorator to manually mark a parameter as being an injection target on injectable
 * classes. This can be used to override the dependency key of a given parameter.
 * @param {DependencyKey} key
 * @constructor
 */
export const InjectParam = (key: DependencyKey): ParameterDecorator => {
    return (target, property, paramIndex) => {
        if ( !Reflect.getMetadata(DEPENDENCY_KEYS_METADATA_KEY, target) ) {
            Reflect.defineMetadata(DEPENDENCY_KEYS_METADATA_KEY, initDependencyMetadata(target), target)
        }

        const meta = Reflect.getMetadata(DEPENDENCY_KEYS_METADATA_KEY, target)
        const req = meta.firstWhere('paramIndex', '=', paramIndex)
        if ( req ) {
            req.key = key
            req.overridden = true
        } else {
            meta.push({
                paramIndex,
                key,
                overridden: true
            })
        }

        Reflect.defineMetadata(DEPENDENCY_KEYS_METADATA_KEY, meta, target)
    }
}

/**
 * Class decorator that registers the class as a singleton instance in the global container.
 * @param {string} name
 */
export const Singleton = (name?: string): ClassDecorator => {
    return (target) => {
        if ( isInstantiable(target) ) {
            const injectionType: InjectionType = {
                type: name ? 'named' : 'singleton',
                ...(name ? { name } : {})
            }

            Reflect.defineMetadata(DEPENDENCY_KEYS_SERVICE_TYPE_KEY, injectionType, target)
            Injectable()(target)

            if ( name ) {
                Container.getContainer().registerNamed(name, target)
            } else {
                Container.getContainer().register(target)
            }
        }
    }
}