path: root/src/fields/List.ts

import { action, computed, makeObservable, observable } from 'mobx';
import { alias, list as serializrList, serializable } from 'serializr';
import { ScriptingGlobals } from '../client/util/ScriptingGlobals';
import { Deserializable, afterDocDeserialize, autoObject } from '../client/util/SerializationHelper';
import { Field, FieldType, StrListCast } from './Doc';
import { FieldTuples, Self, SelfProxy } from './DocSymbols';
import { Copy, FieldChanged, Parent, ToJavascriptString, ToScriptString, ToString } from './FieldSymbols';
import { ObjGetRefFields, ObjectField } from './ObjectField';
import { ProxyField } from './Proxy';
import { RefField } from './RefField';
import { containedFieldChangedHandler, deleteProperty, getter, setter } from './util';

function toObjectField(field: FieldType) {
    return field instanceof RefField ? new ProxyField(field) : field;
}

function toRealField(field: FieldType) {
    return field instanceof ProxyField ? field.value : field;
}

type StoredType<T extends FieldType> = T extends RefField ? ProxyField<T> : T;

export const ListFieldName = 'fields';
@Deserializable('list')
class ListImpl<T extends FieldType> extends ObjectField {
    static listHandlers: any = {
        /// Mutator methods
        copyWithin() {
            throw new Error('copyWithin not supported yet');
        },
        fill(value: any, start?: number, end?: number) {
            if (value instanceof RefField) {
                throw new Error('fill with RefFields not supported yet');
            }
            const res = this[Self].__fieldTuples.fill(value, start, end);
            this[SelfProxy][FieldChanged]?.();
            return res;
        },
        pop(): any {
            const field = toRealField(this[Self].__fieldTuples.pop());
            this[SelfProxy][FieldChanged]?.();
            return field;
        },
        push: action(function (this: ListImpl<any>, ...itemsIn: any[]) {
            const items = itemsIn.map(toObjectField);

            const list = this[Self];
            const { length } = list.__fieldTuples;
            for (let i = 0; i < items.length; i++) {
                const item = items[i];
                // TODO Error checking to make sure parent doesn't already exist
                if (item instanceof ObjectField) {
                    item[Parent] = list;
                    item[FieldChanged] = containedFieldChangedHandler(this[SelfProxy], i + length, item);
                }
            }
            const res = list.__fieldTuples.push(...items);
            this[SelfProxy][FieldChanged]?.({ op: '$addToSet', items, length: length + items.length });
            return res;
        }),
        reverse() {
            const res = this[Self].__fieldTuples.reverse();
            this[SelfProxy][FieldChanged]?.();
            return res;
        },
        shift() {
            const res = toRealField(this[Self].__fieldTuples.shift());
            this[SelfProxy][FieldChanged]?.();
            return res;
        },
        sort(cmpFunc: any) {
            this[Self].__realFields; // coerce retrieving entire array
            const res = this[Self].__fieldTuples.sort(cmpFunc ? (first: any, second: any) => cmpFunc(toRealField(first), toRealField(second)) : undefined);
            this[SelfProxy][FieldChanged]?.();
            return res;
        },
        splice: action(function (this: any, start: number, deleteCount: number, ...itemsIn: any[]) {
            this[Self].__realFields; // coerce retrieving entire array
            const items = itemsIn.map(toObjectField);
            const list = this[Self];
            const removed = list.__fieldTuples.filter((item: any, i: number) => i >= start && i < start + deleteCount);
            for (let i = 0; i < items.length; i++) {
                const item = items[i];
                // TODO Error checking to make sure parent doesn't already exist
                // TODO Need to change indices of other fields in array
                if (item instanceof ObjectField) {
                    item[Parent] = list;
                    item[FieldChanged] = containedFieldChangedHandler(this, i + start, item);
                }
            }
            const hintArray: { val: any; index: number }[] = [];
            for (let i = start; i < start + deleteCount; i++) {
                hintArray.push({ val: list.__fieldTuples[i], index: i });
            }
            const res = list.__fieldTuples.splice(start, deleteCount, ...items);
            // the hint object sends the starting index of the slice and the number
            // of elements to delete.
            this[SelfProxy][FieldChanged]?.(
                items.length === 0 && deleteCount
                    ? { op: '$remFromSet', items: removed, hint: { start, deleteCount }, length: list.__fieldTuples.length }
                    : items.length && !deleteCount && start === list.__fieldTuples.length
                      ? { op: '$addToSet', items, length: list.__fieldTuples.length }
                      : undefined
            );
            return res.map(toRealField);
        }),
        unshift(...itemsIn: any[]) {
            const items = itemsIn.map(toObjectField);
            const list = this[Self];
            for (let i = 0; i < items.length; i++) {
                const item = items[i];
                // TODO Error checking to make sure parent doesn't already exist
                // TODO Need to change indices of other fields in array
                if (item instanceof ObjectField) {
                    item[Parent] = list;
                    item[FieldChanged] = containedFieldChangedHandler(this, i, item);
                }
            }
            const res = this[Self].__fieldTuples.unshift(...items);
            this[SelfProxy][FieldChanged]?.();
            return res;
        },
        /// Accessor methods
        concat: action(function (this: any, ...items: any[]) {
            this[Self].__realFields;
            return this[Self].__fieldTuples.map(toRealField).concat(...items);
        }),
        includes(valueToFind: any, fromIndex: number) {
            if (valueToFind instanceof RefField) {
                return this[Self].__realFields.includes(valueToFind, fromIndex);
            }
            return this[Self].__fieldTuples.includes(valueToFind, fromIndex);
        },
        indexOf(valueToFind: any, fromIndex: number) {
            if (valueToFind instanceof RefField) {
                return this[Self].__realFields.indexOf(valueToFind, fromIndex);
            }
            return this[Self].__fieldTuples.indexOf(valueToFind, fromIndex);
        },
        join(separator: any) {
            this[Self].__realFields;
            return this[Self].__fieldTuples.map(toRealField).join(separator);
        },
        lastElement() {
            return this[Self].__realFields.lastElement();
        },
        lastIndexOf(valueToFind: any, fromIndex: number) {
            if (valueToFind instanceof RefField) {
                return this[Self].__realFields.lastIndexOf(valueToFind, fromIndex);
            }
            return this[Self].__fieldTuples.lastIndexOf(valueToFind, fromIndex);
        },
        slice(begin: number, end: number) {
            this[Self].__realFields;
            return this[Self].__fieldTuples.slice(begin, end).map(toRealField);
        },

        /// Iteration methods
        entries() {
            return this[Self].__realFields.entries();
        },
        every(callback: any, thisArg: any) {
            return this[Self].__realFields.every(callback, thisArg);
            // TODO This is probably more efficient, but technically the callback can take the array, which would mean we would have to map the actual array anyway.
            // If we don't want to support the array parameter, we should use this version instead
            // return this[Self].__fieldTuples.every((element:any, index:number, array:any) => callback(toRealField(element), index, array), thisArg);
        },
        filter(callback: any, thisArg: any) {
            return this[Self].__realFields.filter(callback, thisArg);
            // TODO This is probably more efficient, but technically the callback can take the array, which would mean we would have to map the actual array anyway.
            // If we don't want to support the array parameter, we should use this version instead
            // return this[Self].__fieldTuples.filter((element:any, index:number, array:any) => callback(toRealField(element), index, array), thisArg);
        },
        find(callback: any, thisArg: any) {
            return this[Self].__realFields.find(callback, thisArg);
            // TODO This is probably more efficient, but technically the callback can take the array, which would mean we would have to map the actual array anyway.
            // If we don't want to support the array parameter, we should use this version instead
            // return this[Self].__fieldTuples.find((element:any, index:number, array:any) => callback(toRealField(element), index, array), thisArg);
        },
        findIndex(callback: any, thisArg: any) {
            return this[Self].__realFields.findIndex(callback, thisArg);
            // TODO This is probably more efficient, but technically the callback can take the array, which would mean we would have to map the actual array anyway.
            // If we don't want to support the array parameter, we should use this version instead
            // return this[Self].__fieldTuples.findIndex((element:any, index:number, array:any) => callback(toRealField(element), index, array), thisArg);
        },
        forEach(callback: any, thisArg: any) {
            return this[Self].__realFields.forEach(callback, thisArg);
            // TODO This is probably more efficient, but technically the callback can take the array, which would mean we would have to map the actual array anyway.
            // If we don't want to support the array parameter, we should use this version instead
            // return this[Self].__fieldTuples.forEach((element:any, index:number, array:any) => callback(toRealField(element), index, array), thisArg);
        },
        map(callback: any, thisArg: any) {
            return this[Self].__realFields.map(callback, thisArg);
            // TODO This is probably more efficient, but technically the callback can take the array, which would mean we would have to map the actual array anyway.
            // If we don't want to support the array parameter, we should use this version instead
            // return this[Self].__fieldTuples.map((element:any, index:number, array:any) => callback(toRealField(element), index, array), thisArg);
        },
        reduce(callback: any, initialValue: any) {
            return this[Self].__realFields.reduce(callback, initialValue);
            // TODO This is probably more efficient, but technically the callback can take the array, which would mean we would have to map the actual array anyway.
            // If we don't want to support the array parameter, we should use this version instead
            // return this[Self].__fieldTuples.reduce((acc:any, element:any, index:number, array:any) => callback(acc, toRealField(element), index, array), initialValue);
        },
        reduceRight(callback: any, initialValue: any) {
            return this[Self].__realFields.reduceRight(callback, initialValue);
            // TODO This is probably more efficient, but technically the callback can take the array, which would mean we would have to map the actual array anyway.
            // If we don't want to support the array parameter, we should use this version instead
            // return this[Self].__fieldTuples.reduceRight((acc:any, element:any, index:number, array:any) => callback(acc, toRealField(element), index, array), initialValue);
        },
        some(callback: any, thisArg: any) {
            return this[Self].__realFields.some(callback, thisArg);
            // TODO This is probably more efficient, but technically the callback can take the array, which would mean we would have to map the actual array anyway.
            // If we don't want to support the array parameter, we should use this version instead
            // return this[Self].__fieldTuples.some((element:any, index:number, array:any) => callback(toRealField(element), index, array), thisArg);
        },
        values() {
            return this[Self].__realFields.values();
        },
        [Symbol.iterator]() {
            return this[Self].__realFields.values();
        },
    };
    static listGetter(target: any, prop: string | symbol, receiver: any): any {
        if (Object.prototype.hasOwnProperty.call(ListImpl.listHandlers, prop)) {
            return ListImpl.listHandlers[prop];
        }
        return getter(target, prop, receiver);
    }
    constructor(fields?: T[]) {
        super();
        makeObservable(this);
        const list = new Proxy<this>(this, {
            set: setter,
            get: ListImpl.listGetter,
            ownKeys: target => {
                const keys = Object.keys(target.__fieldTuples);
                return [...keys, FieldTuples, Self, SelfProxy, '__realFields'];
            },
            getOwnPropertyDescriptor: (target, prop) => {
                if (prop in target[FieldTuples]) {
                    return {
                        configurable: true, // TODO Should configurable be true?
                        enumerable: true,
                    };
                }
                return Reflect.getOwnPropertyDescriptor(target, prop);
            },
            deleteProperty: deleteProperty,
            defineProperty: () => {
                throw new Error("Currently properties can't be defined on documents using Object.defineProperty");
            },
        });
        // eslint-disable-next-line no-use-before-define
        this[SelfProxy] = list as any as List<FieldType>; // bcz: ugh .. don't know how to convince typesecript that list is a List
        if (fields) {
            this[SelfProxy].push(...fields);
        }
        // eslint-disable-next-line no-constructor-return
        return list; // need to return the proxy here, otherwise we don't get any of our list handler functions
    }

    [key: number]: T | (T extends RefField ? Promise<T> : never);

    // this requests all ProxyFields at the same time to avoid the overhead
    // of separate network requests and separate updates to the React dom.
    @computed private get __realFields() {
        const unrequested = this[FieldTuples].filter(f => f instanceof ProxyField && f.needsRequesting).map(f => f as ProxyField<RefField>);
        // if we find any ProxyFields that don't have a current value, then
        // start the server request for all of them
        if (unrequested.length) {
            const batchPromise = ObjGetRefFields(unrequested.map(p => p.fieldId));
            // as soon as we get the fields from the server, set all the list values in one
            // action to generate one React dom update.
            const allSetPromise = batchPromise.then(action(pfields => unrequested.map(toReq => toReq.setValue(pfields[toReq.fieldId]))));
            // we also have to mark all lists items with this promise so that any calls to them
            // will await the batch request and return the requested field value.
            unrequested.forEach(p => p.setExternalValuePromise(allSetPromise));
        }
        return this[FieldTuples].map(toRealField);
    }

    @serializable(alias(ListFieldName, serializrList(autoObject(), { afterDeserialize: afterDocDeserialize })))
    private get __fieldTuples() {
        return this[FieldTuples];
    }

    private set __fieldTuples(value) {
        this[FieldTuples] = value;
        Object.keys(value).forEach(key => {
            const item = value[Number(key)];
            if (item instanceof ObjectField) {
                item[Parent] = this[Self];
                item[FieldChanged] = containedFieldChangedHandler(this[SelfProxy], Number(key), item);
            }
        });
    }

    [Copy]() {
        const copiedData = this[Self].__fieldTuples.map(f => (f instanceof ObjectField ? f[Copy]() : f));
        const deepCopy = new ListImpl<T>(copiedData as any);
        return deepCopy;
    }

    // @serializable(alias("fields", list(autoObject())))
    @observable
    private [FieldTuples]: StoredType<T>[] = [];
    private [Self] = this;
    // eslint-disable-next-line no-use-before-define
    private [SelfProxy]: List<FieldType>; // also used in utils.ts even though it won't be found using find all references

    [ToScriptString]()     { return `new List(${this[ToJavascriptString]()})`; } // prettier-ignore
    [ToJavascriptString]() { return `[${(this as any).map((field: any) => Field.toScriptString(field))}]`; } // prettier-ignore
    [ToString]()           { return `[${(this as any).map((field: any) => Field.toString(field))}]`; } // prettier-ignore
}

// declare List as a type so you can use it in type declarations, e.g., { l: List, ...}
export type List<T extends FieldType> = ListImpl<T> & (T | (T extends RefField ? Promise<T> : never))[];
// decalre List as a value so you can invoke 'new' on it, e.g., new List<Doc>()
// eslint-disable-next-line no-redeclare
export const List: { new <T extends FieldType>(fields?: T[]): List<T> } = ListImpl as any;

ScriptingGlobals.add('List', List);
// eslint-disable-next-line prefer-arrow-callback
ScriptingGlobals.add(function compareLists(l1: any, l2: any) {
    const L1 = StrListCast(l1);
    const L2 = StrListCast(l2);
    return !L1 && !L2 ? true : L1 && L2 && L1.length === L2.length && L2.reduce((p, v) => p && L1.includes(v), true);
}, 'compare two lists');