import { Nullable } from 'tsdef';

import { FileAction } from '../types/action.types';
import { FileArray } from '../types/file.types';
import { Logger } from '../util/logger';

interface SanitizeFiles {
    (mode: 'files', rawArray: FileArray | any): {
        sanitizedArray: FileArray;
        errorMessages: string[];
    };
    (mode: 'folderChain', rawArray: Nullable<FileArray> | any): {
        sanitizedArray: FileArray;
        errorMessages: string[];
    };
    (mode: 'fileActions', rawArray: FileAction[] | any): {
        sanitizedArray: FileAction[];
        errorMessages: string[];
    };
}

export const sanitizeInputArray: SanitizeFiles = (mode: string, rawArray: any[]) => {
    const sanitizedFiles = [];
    const errorMessages: string[] = [];

    if ((mode === 'folderChain' || mode === 'fileActions') && !rawArray) {
        // Do nothing, we allow folder chain to be null.
    } else if (!Array.isArray(rawArray)) {
        errorMessages.push(
            `Expected "${mode}" prop to be an array, got "${typeof rawArray}" instead.`
        );
    } else {
        let nonObjectFileCount = 0;
        let missingFieldFileCount = 0;
        const seenIds = new Set<string>();
        const duplicateIds = new Set<string>();

        for (let i = 0; i < rawArray.length; ++i) {
            const item = rawArray[i];
            if (!item) {
                if (mode === 'fileActions') nonObjectFileCount++;
                else sanitizedFiles.push(null);
            } else if (typeof item !== 'object') {
                nonObjectFileCount++;
            } else {
                if (!item.id || (mode !== 'fileActions' && !item.name)) {
                    missingFieldFileCount++;
                } else if (seenIds.has(item.id)) {
                    duplicateIds.add(item.id);
                } else {
                    seenIds.add(item.id);
                    sanitizedFiles.push(item);
                }
            }
        }

        if (nonObjectFileCount) {
            errorMessages.push(
                `Detected ${nonObjectFileCount} file(s) of invalid type. Remember ` +
                    `that "files" array should contain either objects or nulls.`
            );
        }
        if (missingFieldFileCount) {
            errorMessages.push(
                `Detected ${missingFieldFileCount} file(s) that are missing the ` +
                    `required fields. Remember that file object should define an ` +
                    `"id" and a "name".`
            );
        }
        if (duplicateIds.size > 0) {
            const repeatedIdsString = '"' + Array.from(duplicateIds).join('", "') + '"';
            errorMessages.push(
                `Detected ${duplicateIds.size} file IDs that are used multiple ` +
                    `times. Remember that each file should have a unique IDs. The ` +
                    `following IDs were seen multiple times: ${repeatedIdsString}`
            );
        }
    }

    if (errorMessages.length > 0) {
        const errorMessageString = '\n- ' + errorMessages.join('\n- ');
        let arrayString: string;
        let itemString: string;
        if (mode === 'folderChain') {
            arrayString = 'folder chain';
            itemString = 'files';
        } else if (mode === 'fileActions') {
            arrayString = 'file actions';
            itemString = 'file actions';
        } else {
            // mode === 'files'
            arrayString = 'files';
            itemString = 'files';
        }

        Logger.error(
            `Errors were detected when sanitizing the ${arrayString} array. ` +
                `Offending ${itemString} were removed from the array. Summary of ` +
                `validation errors: ${errorMessageString}`
        );
    }

    return {
        sanitizedArray: sanitizedFiles,
        errorMessages,
    };
};