import {Proxy as FacilityProxy} from '@labshare/facility';
import {requestItem} from './models/request';
import {find, isNil} from 'lodash'

export class Requests {

    private facilityId;
    private loginName;

    constructor(facilityId, loginName) {
        this.facilityId = facilityId;
        this.loginName = loginName;
    }

    public async getAll(listName) {
        const proxyFacility = new FacilityProxy.Facility({
            facilityId: this.facilityId || '/',
            loginName: this.loginName
        });

        const settings = await proxyFacility.getSettings();

        const proxyItems = new FacilityProxy.Items({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName
        });

        const requests = await proxyItems.getView('All Items');
        this.objectToRequest(requests);
        return requests;
    }

    objectToRequest(data) {
        const request = new requestItem();
        for (let prop in data) {
            request[prop] = data[prop];
        }
        return request;
    }

    public async getOne(listName, itemId) {
        if (isNaN(itemId) && itemId === 'new') {
            return this.getNew(listName);
        } else {
            const proxyList = new FacilityProxy.Lists({
                facilityId: this.facilityId || '/',
                loginName: this.loginName,
                listName: listName
            });

            const settings = await proxyList.getSettings();
            const childLists = settings["ChildList"];
            let relatedItems: any = [];

            const proxyItems = new FacilityProxy.Items({
                facilityId: this.facilityId || '/',
                loginName: this.loginName,
                listName
            });

            const data = await proxyItems.getOne(itemId);
            let request = this.objectToRequest(data);
            if (childLists && childLists.length > 0) {
                for (let i = 0; i < childLists.length; i++) {
                    const parentField = childLists[i].ParentFieldName;
                    let relatedData;
                    if (isNil(parentField)) {
                        relatedData = await this.getRelatedItems(childLists[i].ListName || 'Gel Request Samples',
                            childLists[i].LookupFieldName || 'RequestID', request.ID);
                    } else {
                        relatedData = await this.getRelatedItems(childLists[i].ListName || 'Gel Request Samples',
                            childLists[i].LookupFieldName || 'RequestID', request[parentField]);
                    }
                    relatedItems.push({listName: childLists[i].ListName, items: relatedData.items});
                }
            }
            request.relatedItems = relatedItems;
            return request;
        }
    }

    public async getNew(listName) {

        const proxyList = new FacilityProxy.Lists({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName: listName
        });

        const settings = await proxyList.getSettings();
        const childLists = settings["ChildList"];
        let relatedItems: any = [];

        const proxyItems = new FacilityProxy.Items({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName
        });

        const request = await proxyItems.getNew();
        if (childLists && childLists.length > 0) {
            for (let i = 0; i < childLists.length; i++) {
                const data = await this.getRelatedItemFields(childLists[i].ListName);
                relatedItems.push({
                    listName: childLists[i].ListName,
                    items: [data]
                });
            }
        }
        request["relatedItems"] = relatedItems;
        return request;
    }

    public async getRelatedItemFields(listName) {
        const proxyItems = new FacilityProxy.Items({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName
        });
        const relatedItems = proxyItems.getNew();
        return relatedItems;
    }

    public async getRelatedItems(listName, internalName, value) {
        const proxyItems = new FacilityProxy.Items({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName
        });
        const relatedItems = proxyItems.find({internalName: internalName, value: value});
        return relatedItems;
    }

    public async addOrUpdateRelatedItems(listName, items, lookupFieldName, lookupValue, copyValueFromRequest, addedItem) {
        const proxyItems = new FacilityProxy.Items({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName
        });
        let Ids = [];
        for (let i = 0; i < items.length; i++) {
            let lookupField = find(items[i].Properties, {'internalName': lookupFieldName});
            if (lookupField) {
                if (lookupField.type === 'Lookup') {
                    if (lookupField && lookupField.value && lookupField.value.Refs && lookupField.value.Refs.length > 0) {
                        lookupField.value.Refs[0].Id = lookupValue;
                    } else {
                        lookupField = {};
                        lookupField.internalName = lookupFieldName;
                        lookupField.value = {'Refs': [{'Id': lookupValue}]};
                        lookupField.type = 'Lookup';
                        items[i].Properties.push(lookupField);
                    }
                } else {
                    if (lookupField) {
                        lookupField.value = lookupValue;
                    } else {
                        lookupField = {};
                        lookupField.internalName = lookupFieldName;
                        lookupField.value = lookupValue;
                        lookupField.type = 'Text';
                        items[i].Properties.push(lookupField);
                    }
                }
            } else {
                Ids.push(
                    'Can not find the lookup Filed:' + lookupFieldName + ' for item:' + i
                )
            }

            if (copyValueFromRequest) {
                for (let j = 0; j < copyValueFromRequest.length; j++) {
                    let sourceProperty = find(addedItem.Properties, {'internalName': copyValueFromRequest[j].source});
                    let targetProperty = find(items[i].Properties, {'internalName': copyValueFromRequest[j].target});
                    if (sourceProperty && targetProperty) {
                        if (targetProperty.type === 'Lookup' || targetProperty.type === 'User') {
                            targetProperty.value = {
                                Refs: [
                                    {Id: addedItem.ID}
                                ]
                            }
                        } else {
                            if (
                                (sourceProperty.type === 'Lookup' || sourceProperty.type === 'User')
                            ) {
                                if (sourceProperty.value && sourceProperty.value.Refs && sourceProperty.value.Refs[0]) {
                                    targetProperty.value = sourceProperty.value.Refs[0].Value;
                                } else {
                                    targetProperty.value = null;
                                }
                            } else {
                                targetProperty.value = sourceProperty.value;
                            }

                        }
                    }
                }
            }

            if (items[i].ID === null) {
                Ids.push(
                    await proxyItems.add(items[i])
                );
            } else {
                await proxyItems.update(items[i].ID, items[i]);
                Ids.push(
                    items[i].ID
                );
            }
        }
        return Ids;
    }

    public async update(listName, itemId, item) {
        const proxyList = new FacilityProxy.Lists({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName: listName
        });

        const settings = await proxyList.getSettings();
        const childLists = settings["ChildList"];

        const proxyItems = new FacilityProxy.Items({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName
        });

        await proxyItems.update(itemId, item);
        const Id = itemId;
        let relatedIds = [], lookupValue;
        if (item.relatedItems && item.relatedItems.length > 0) {
            for (let i = 0; i < item.relatedItems.length; i++) {
                const relatedList = find(childLists, {'ListName': item.relatedItems[i].listName});
                const parentField = childLists[i].ParentFieldName;
                if (isNil(parentField)) {
                    lookupValue = item.ID;
                } else {
                    lookupValue = (find(item.Properties, {internalName: parentField}) || {}).value;
                }
                relatedIds.push({
                    listName: item.relatedItems[i].listName,
                    Ids: await this.updateRelatedItems(
                        item.relatedItems[i].listName,
                        item.relatedItems[i].items,
                        relatedList.LookupFieldName,
                        lookupValue,
                        relatedList.copyValueFromRequest,
                        item
                    )
                });
            }
        }
        return {id: Id, relatedItemIds: relatedIds};
    }

    public async updateRelatedItems(listName, items, lookupField, lookupId, copyValueFromRequest, item) {
        let Ids = [];
        if (items.length > 0) {
            Ids = await this.addOrUpdateRelatedItems(
                listName,
                items,
                lookupField,
                lookupId,
                copyValueFromRequest,
                item
            );
        }
        return Ids;
    }

    public async add(listName, item) {
        const proxyList = new FacilityProxy.Lists({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName: listName
        });

        const settings = await proxyList.getSettings();
        const childLists = settings["ChildList"];

        const proxyItems = new FacilityProxy.Items({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName
        });

        const Id = await proxyItems.add(item);
        const addedItem = await proxyItems.getOne(Id);
        let relatedIds = [], lookupValue;
        if (item.relatedItems && item.relatedItems.length > 0) {
            for (let i = 0; i < item.relatedItems.length; i++) {
                const relatedList = find(childLists, {'ListName': item.relatedItems[i].listName});
                const parentField = childLists[i].ParentFieldName;
                if (isNil(parentField)) {
                    lookupValue = Id;
                } else {
                    lookupValue = (find(addedItem.Properties, {internalName: parentField}) || {}).value;
                }
                relatedIds.push({
                    listName: item.relatedItems[i].listName,
                    Ids: await this.addOrUpdateRelatedItems(
                        item.relatedItems[i].listName,
                        item.relatedItems[i].items,
                        relatedList.LookupFieldName,
                        lookupValue,
                        relatedList.copyValueFromRequest,
                        addedItem)
                });
            }
        }

        return {id: Id, relatedItemIds: relatedIds};
    }

    public async remove(listName, itemId) {
        const proxyItems = new FacilityProxy.Items({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName
        });

        if (itemId) {
            let relatedIds = [];
            let item = await this.getOne(listName, itemId);
            await proxyItems.remove(itemId);

            if (item instanceof requestItem && item.relatedItems && item.relatedItems.length > 0) {
                for (let i = 0; i < item.relatedItems.length; i++) {
                    relatedIds.push({
                        listName: item.relatedItems[i].listName,
                        Ids: await this.removeRelatedItems(item.relatedItems[i].listName, item.relatedItems[i].items)
                    });
                }
            }
            return {id: itemId, relatedItemIds: relatedIds}
        } else {
            return {id: null, relatedItemIds: []};
        }
    }

    public async removeRelatedItems(listName, items) {
        let Ids = [];
        const proxyItems = new FacilityProxy.Items({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName
        });
        for (let i = 0; i < items.length; i++) {
            await proxyItems.remove(items[i].ID);
            Ids.push(items[i].ID);
        }
        return Ids;
    }

    public async updateMembers(listName, itemId, item) {
        const proxyItems = new FacilityProxy.Items({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName
        });

        const proxyProjects = new FacilityProxy.Items({
            facilityId: this.facilityId || '/',
            loginName: this.loginName,
            listName: 'Projects'
        });

        const request = await proxyItems.update(itemId, item);

        const requestMembers = find(request['Properties'], {'internalName': 'ProjectMembers'}) ||
            find(request['Properties'], {'internalName': 'Project_x0020_Members'});

        const projectProperty = find(item.Properties, {'internalName': 'Project'});

        const project = await proxyItems.getOne(projectProperty.value);

        const projectMembers = find(project.Properties, {'internalName': 'ProjectMembers'}) ||
            find(project.Properties, {'internalName': 'Project_x0020_Members'});

        if (projectMembers && requestMembers) {
            projectMembers.value = requestMembers.value;
        }

        await proxyProjects.update(itemId, item);

        return request;
    }
}