import {
    fillWithDefaultSettings,
    getComposedPrimaryKeyOfDocumentData,
    getLengthOfPrimaryKey
} from 'nxdb-old/src/rx-schema-helper';
import { flatCloneDocWithMeta } from 'nxdb-old/src/rx-storage-helper';
import type {
    BulkWriteRow,
    ById,
    RxDocumentData,
    RxJsonSchema,
    RxStorageInstanceReplicationState,
    RxStorageReplicationMeta,
    WithDeleted
} from 'nxdb-old/src/types';
import { getDefaultRevision, createRevision, now } from 'nxdb-old/src/plugins/utils';


export function getRxReplicationMetaInstanceSchema(
    replicatedDocumentsSchema: RxJsonSchema<RxDocumentData<any>>,
    encrypted: boolean
): RxJsonSchema<RxDocumentData<RxStorageReplicationMeta>> {
    const parentPrimaryKeyLength = getLengthOfPrimaryKey(replicatedDocumentsSchema);

    const baseSchema: RxJsonSchema<RxStorageReplicationMeta> = {
        primaryKey: {
            key: 'id',
            fields: [
                'itemId',
                'isCheckpoint'
            ],
            separator: '|'
        },
        type: 'object',
        version: 0,
        additionalProperties: false,
        properties: {
            id: {
                type: 'string',
                minLength: 1,
                // add +1 for the '|' and +1 for the 'isCheckpoint' flag
                maxLength: parentPrimaryKeyLength + 2
            },
            isCheckpoint: {
                type: 'string',
                enum: [
                    '0',
                    '1'
                ],
                minLength: 1,
                maxLength: 1
            },
            itemId: {
                type: 'string',
                maxLength: parentPrimaryKeyLength
            },
            data: {
                type: 'object',
                additionalProperties: true
            },
            isResolvedConflict: {
                type: 'string'
            }
        },
        required: [
            'id',
            'isCheckpoint',
            'itemId',
            'data'
        ]
    };
    if (encrypted) {
        baseSchema.encrypted = ['data'];
    }
    const metaInstanceSchema: RxJsonSchema<RxDocumentData<RxStorageReplicationMeta>> = fillWithDefaultSettings(baseSchema);
    return metaInstanceSchema;
}



/**
 * Returns the document states of what the fork instance
 * assumes to be the latest state on the master instance.
 */
export function getAssumedMasterState<RxDocType>(
    state: RxStorageInstanceReplicationState<RxDocType>,
    docIds: string[]
): Promise<ById<{
    docData: WithDeleted<RxDocType>;
    metaDocument: RxDocumentData<RxStorageReplicationMeta>;
}>> {
    return state.input.metaInstance.findDocumentsById(
        docIds.map(docId => {
            const useId = getComposedPrimaryKeyOfDocumentData(
                state.input.metaInstance.schema,
                {
                    itemId: docId,
                    isCheckpoint: '0'
                }
            );
            return useId;
        }),
        true
    ).then(metaDocs => {
        const ret: {
            [docId: string]: {
                docData: RxDocumentData<RxDocType>;
                metaDocument: RxDocumentData<RxStorageReplicationMeta>;
            };
        } = {};
        Object
            .values(metaDocs)
            .forEach((metaDoc) => {
                ret[metaDoc.itemId] = {
                    docData: metaDoc.data,
                    metaDocument: metaDoc
                };
            });

        return ret;
    });
}


export function getMetaWriteRow<RxDocType>(
    state: RxStorageInstanceReplicationState<RxDocType>,
    newMasterDocState: WithDeleted<RxDocType>,
    previous?: RxDocumentData<RxStorageReplicationMeta>,
    isResolvedConflict?: string
): BulkWriteRow<RxStorageReplicationMeta> {
    const docId: string = (newMasterDocState as any)[state.primaryPath];
    const newMeta: RxDocumentData<RxStorageReplicationMeta> = previous ? flatCloneDocWithMeta(
        previous
    ) : {
        id: '',
        isCheckpoint: '0',
        itemId: docId,
        data: newMasterDocState,
        _attachments: {},
        _deleted: false,
        _rev: getDefaultRevision(),
        _meta: {
            lwt: 0
        }
    };
    newMeta.data = newMasterDocState;
    newMeta.isResolvedConflict = isResolvedConflict;
    newMeta._meta.lwt = now();
    newMeta.id = getComposedPrimaryKeyOfDocumentData(
        state.input.metaInstance.schema,
        newMeta
    );
    newMeta._rev = createRevision(
        state.input.identifier,
        previous
    );
    return {
        previous,
        document: newMeta
    };
}