import { IRecord } from 'ember-movenium/interfaces/record';
import { getOwner } from '@ember/application';
import EmberObject, { get, set } from '@ember/object';
import { intersect } from '@ember/object/computed';
import { IField, IOptions } from 'ember-movenium/interfaces/forms';

export function save_record(record: IRecord, owner: any) {
    if (!owner) throw new Error('Call this with save_record(record, this)')
    const formsService = getOwner(owner).lookup('service:forms')
    const form = owner.form ? owner.form : owner.args.form
    return new Promise(async (resolve, reject) => {

        const fields = formsService.fields(form)
        const children: any[] = []

        for (const field in fields) {
            if (field) {
                const currentField = get(fields, field) as IField

                if (get(currentField, 'type') === 'databasearray' && field !== 'involved') {

                    const obj = EmberObject.extend({
                        fieldsInCommon: intersect('parentFields', 'childFields'),
                    }).create({
                        parentFields: Object.keys(fields),
                        childFields: Object.keys(formsService.fields((currentField.options as IOptions).form)),
                    })

                    if (get(record, field) as IField) {
                        get(record, field).forEach((child: any) => {
                            get(obj, 'fieldsInCommon').forEach(commonField => {
                                if (get(record, commonField)) set(child, commonField, get(record, commonField))
                            })
                            children.push(child)
                        })
                    }
                }
            }
        }

        if (children.length > 0) {
            await record.validate()
            try {
                if (get(record, 'isValid') && get(record, 'hasDirtyAttributes')) {
                    for (const child of children) {
                        await child.validate()
                        if (!get(child, 'isValid')) {
                            const errors = await child.errors
                            if (errors && errors.firstObject) throw new Error(errors.firstObject.message + ' (' + errors.firstObject.attribute + ')')
                            else await child.save() // just try to save so it goes to catch if no record errors
                        } else continue
                    }
                    const promises = children.map(child => {
                        return child.save()
                    })
                    await Promise.all(promises)
                    await record.save()
                    resolve()
                } else {
                    resolve()
                }
            } catch (e) {
                reject(e)
            }

        } else {
            try {
                await record.validate()
                if (get(record, 'isValid')) await record.save()
                resolve()
            } catch (e) {
                reject(e)
            }
        }
    })

}

export default { save_record }