import { removeFromArray } from "../utils";
import { CollectionField } from "./collection";

export interface CollectionInterface<T> {
    new(relation: CollectionField<any, any>, instance): BaseCollectionInterface<T>
}

export abstract class BaseCollectionInterface<T> {
    constructor(
        protected readonly relation: CollectionField<any, any>,
        protected readonly instance: any,
    ) {

    }

    get collection() {
        return this.relation.access.get.call(this.instance);
    }

    abstract instanciate(initial: Iterable<T>): any;

    abstract items(): Iterable<T>;

    abstract storeItem(item: T): void;
    abstract unstoreItem(item: T): void;

    asSet() {
        return new Set<T>(this.items());
    }
}

export class ArrayInterface<T> extends BaseCollectionInterface<T> {
    constructor(relation: CollectionField<any, any>, instance) {
        super(relation, instance);
    }

    instanciate(initial) {
        return [...initial];
    }

    items(): Iterable<T> {
        return this.collection;
    }

    storeItem(object: T): void {
        this.collection.push(object);
    }
    unstoreItem(object: T): void {
        removeFromArray(this.collection, object);
    }
}

export class SetInterface<T> extends BaseCollectionInterface<T> {
    constructor(relation: CollectionField<any, any>, instance) {
        super(relation, instance);
    }

    instanciate(initial?) {
        return new Set(initial);
    }

    items(): Iterable<T> {
        return this.collection;
    }

    storeItem(object: T): void {
        this.collection.add(object);
    }
    unstoreItem(object: T): void {
        this.collection.delete(object);
    }
}

export class ObjectInterface<T> extends BaseCollectionInterface<T> {
    constructor(relation: CollectionField<any, any>, instance) {
        super(relation, instance);
    }

    instanciate(initial) {
        const value = {};
        for (let item of initial) {
            value[this.getIndexKey(item)] = item;
        }
        return value;
    }

    protected getIndexKey(obj) {
        return obj[this.relation.options.indexBy || 'id'];
    }

    items(): Iterable<T> {
        return Object.values(this.collection);
    }

    storeItem(object: T): void {
        this.collection[this.getIndexKey(object)] = object;
    }
    unstoreItem(object: T): void {
        delete this.collection[this.getIndexKey(object)];
    }
}

export class MapInterface<T> extends BaseCollectionInterface<T> {
    constructor(relation: CollectionField<any, any>, instance) {
        super(relation, instance);
    }

    instanciate(initial) {
        const value = new Map();
        for (let item of initial) {
            value.set(this.getIndexKey(item), item);
        }
        return value;
    }

    protected getIndexKey(obj) {
        return obj[this.relation.options.indexBy || 'id'];
    }

    items(): Iterable<T> {
        return this.collection.values();
    }

    storeItem(object: T): void {
        this.collection.set(this.getIndexKey(object), object);
    }
    unstoreItem(object: T): void {
        this.collection.delete(this.getIndexKey(object));
    }
}