import { IDestroyable, ILifetimeContext, ILifetimeManager, ILifetimeSlot } from "./interfaces";
import { argumentNotNull, isDestroyable } from "./traits";

const safeCall = (item: () => void) => {
    try {
        item();
    } catch {
        // silence!
    }
};

const noop = () => { };

const fail = (message: string) => (): never => {
    throw new Error(message);
};

const _emptySlot = Object.freeze({
    has: () => false,

    initialize: noop,

    get: fail("The specified item isn't registered with a lifetime manager"),

    store: noop,

    remove: noop,

    cleanup: noop,
});

const _destroy = (item: unknown) => () => isDestroyable(item) && item.destroy() ;

const _makeCleanup = <T>(value: T, cleanup?: (item: T) => void) =>
    cleanup ? () => cleanup(value) : _destroy(value);

const newSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({
    has: () => false,

    initialize: () => put(pendingSlot(put, remove)),

    get: fail("The slot doesn't hold a value"),

    store: (value, cleanup) => put(valueSlot(value, cleanup, remove)),

    remove: noop,

    cleanup: noop,
});

const pendingSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({
    has: () => false,

    get: fail("The value in this slot doesn't exist"),

    initialize: fail("Cyclic reference detected"),

    store: (value, cleanup) => put(valueSlot(value, cleanup, remove)),

    remove,

    cleanup: noop
});

const valueSlot = <T>(value: T, cleanup: ((item: T) => void) | undefined, remove: () => void) => ({
    has: () => true,

    get: () => value,

    initialize: fail("The slot already has a value"),

    store: fail("The slot already has a value"),

    cleanup: _makeCleanup(value, cleanup),

    remove: remove
});

export class LifetimeManager implements ILifetimeManager {
    private _destroyed = false;

    private readonly _slots: Record<string, ILifetimeSlot<unknown>> = {};

    slot<T>(cookie: string | number): ILifetimeSlot<T> {
        if (cookie in this._slots)
            return this._slots[cookie] as ILifetimeSlot<T>;

        return newSlot<T>(this._put(cookie), this._remove(cookie));
    }

    private readonly _put = (id: string | number) => <T>(slot: ILifetimeSlot<T>) => {
        this._assertNotDestroyed();
        this._slots[id] = slot as ILifetimeSlot<unknown>;
    };

    private readonly _remove = (id: string | number) => () => {
        this._assertNotDestroyed();
        delete this._slots[id];
    };

    private _assertNotDestroyed() {
        if (this._destroyed)
            throw new Error("The lifetime manager is destroyed");

    }

    destroy() {
        if (!this._destroyed) {
            this._destroyed = true;
            Object.values(this._slots).forEach(({ cleanup }) => safeCall(cleanup));
        }
    }

}

export const emptyLifetime = <T>() => () => _emptySlot as ILifetimeSlot<T>;

let nextId = 1;

export const containerLifetime = <T>() => {
    const slotId = nextId ++;
    return (context: ILifetimeContext) =>
        context.ownerSlot<T>(slotId);
};

export const hierarchyLifetime = <T>() => {
    const slotId = nextId++;
    return (context: ILifetimeContext) =>
        context.containerSlot<T>(slotId);
};

/**
 * Creates a lifetime instance bound to the current activation context. This
 * lifetime will store the service instance per activation context. Every
 * top level service resolution will create a new activation context. This
 * context is propagated to subsequent service resolution thus all services
 * with context lifetime will be shared among their consumers. 
 *  
 * @returns The instance of the lifetime.
 */
export const contextLifetime = <T>() => {
    const slotId = nextId++;

    return (context: ILifetimeContext) =>
        context.contextSlot<T>(slotId);
};

const singletons = new LifetimeManager();

/**
 * Creates the lifetime for the service which will allow existence only one
 * instance with the specified {@linkcode typeId}. If there will be created
 * several lifetime instances with same `typeId` in the runtime, they will
 * share the same service instance.
 * 
 * @param typeId The identified for the global instance, usually this is a
 *   fully qualified class name
 * @returns The lifetime instance 
 */
export const singletonLifetime = <T>(typeId: string) => {
    argumentNotNull(typeId, "typeId");

    return () => singletons.slot<T>(typeId);
};

/** Creates a lifetime bound to the specified container. Using this lifetime
 * will create a single service instance per the specified container.
 * 
 * @param container The container which will manage the lifetime for the service
 */
export const containerLifetime = <T>(manager: ILifetimeManager) => {
    const slotId = nextId++;
    return () => manager.slot<T>(slotId);
};