export function assignWithArrays(target: any, ...sources: any[]) {
    sources.filter(source => source != null).forEach(source => {
        Object.keys(source)
            .filter(key => source[key] !== undefined)
            .forEach(key => {
                target[key] = merge(target[key], source[key]);
            });
    });

    return target;
}

function merge(a: any, b: any): any {
    if (Array.isArray(a) && Array.isArray(b)) {
        return [...a, ...b];
    }

    if (a instanceof Map && b instanceof Map) {
        return mergeMap(a, b);
    }

    if (a instanceof Set && b instanceof Set) {
        return mergeSet(a, b);
    }

    return b;
}

function mergeMap<A, B>(a: Map<A, B>, b: Map<A, B>): Map<A, B> {
    const aEntries = Array.from(a);
    const bEntries = Array.from(b);

    const overrides: any[] = bEntries
        .filter(entryB => aEntries.some(entryA => entryA[0] === entryB[0]))
        .map(entryB => {
            const entryA = aEntries.find(entryA => entryA[0] === entryB[0])!;
            return [entryB[0], merge(entryA[1], entryB[1])];
        });

    return new Map<A, B>([...aEntries, ...bEntries, ...overrides]);
}

function mergeSet<T>(a: Set<T>, b: Set<T>): Set<T> {
    const aValues = Array.from(a);
    const bValues = Array.from(b);

    return new Set<T>([...aValues, ...bValues]);
}

export function pick<T, K extends keyof T>(obj: T, ...keys: K[]): Pick<T, K> {
    return <Pick<T, K>>keys.reduce(
        (target, key) => ({ ...target, [key as any]: obj[key] }),
        {},
    );
}