//
//#region Imports ...
const XFileTools = require('../tools/x-file.tools');
const XValueTools = require('../tools/x-value.tools');
const XBaseDescriptor = require('./x-base.descriptor');
const XEnumDescriptor = require('./x-enum.descriptor');
const XTypeDescriptor = require('./x-type.descriptor');
const XClassDescriptor = require('./x-class.descriptor');
const XConstDescriptor = require('./x-const.descriptor');
const XImportDescriptor = require('./x-import.descriptor');
const XExportDescriptor = require('./x-export.descriptor');
const XInterfaceDescriptor = require('./x-interface.descriptor');
//#endregion

/**
 * check an object instance is XFileDescriptor or not ...
 * 
 * @param {any} object proposed object to check ...
 * @returns 
 */
function isDescriptor(object) {
    //
    if (!object) {
        return false;
    }

    //
    let result = false;
    result =
        Array.isArray(object.types) &&
        object.hasOwnProperty('types') &&
        //
        Array.isArray(object.enums) &&
        object.hasOwnProperty('enums') &&
        //
        Array.isArray(object.consts) &&
        object.hasOwnProperty('consts') &&
        //
        Array.isArray(object.classes) &&
        object.hasOwnProperty('classes') &&
        //
        Array.isArray(object.imports) &&
        object.hasOwnProperty('imports') &&
        //
        Array.isArray(object.exports) &&
        object.hasOwnProperty('exports') &&
        //
        Array.isArray(object.interfaces) &&
        object.hasOwnProperty('interfaces');

    //
    return result;
}

/**
 * retrieve base or filled XFileDescriptor object instance ...
 * 
 * @param {any} value a value provider object ...
 * @returns an instance of XFileDescriptor object ...
 */
function createDescriptor(value) {
    //
    let result = {
        types: [XTypeDescriptor.createDescriptor()],
        enums: [XEnumDescriptor.createDescriptor()],
        consts: [XConstDescriptor.createDescriptor()],
        classes: [XClassDescriptor.createDescriptor()],
        imports: [XImportDescriptor.createDescriptor()],
        exports: [XExportDescriptor.createDescriptor()],
        interfaces: [XInterfaceDescriptor.createDescriptor()],
    };

    //
    result.types.pop();
    result.enums.pop();
    result.consts.pop();
    result.classes.pop();
    result.imports.pop();
    result.exports.pop();
    result.interfaces.pop();

    //
    //#region Apply Value ...
    if (value) {
        //
        //#region types ...
        if (XValueTools.hasChildArray(value.types)) {
            result.types = [
                ...value.types
            ];
        }
        //#endregion

        //
        //#region enums ...  
        if (XValueTools.hasChildArray(value.enums)) {
            result.enums = [
                ...value.enums
            ];
        }
        //#endregion

        //
        //#region consts ...
        if (XValueTools.hasChildArray(value.consts)) {
            result.consts = [
                ...value.consts
            ];
        }
        //#endregion

        //
        //#region classes ...
        if (XValueTools.hasChildArray(value.classes)) {
            result.classes = [
                ...value.classes
            ];
        }
        //#endregion

        //
        //#region imports ...
        if (XValueTools.hasChildArray(value.imports)) {
            result.imports = [
                ...value.imports
            ];
        }
        //#endregion

        //
        //#region exports ...
        if (XValueTools.hasChildArray(value.exports)) {
            result.exports = [
                ...value.exports
            ];
        }
        //#endregion

        //
        //#region interfaces ...
        if (XValueTools.hasChildArray(value.interfaces)) {
            result.interfaces = [
                ...value.interfaces
            ];
        }
        //#endregion
    }
    //#endregion

    //
    return result;
}

/**
 * converts an instance of Descriptor to Expression ...
 * 
 * @param descriptor an instance of XFileDescriptor ...
 * @returns creator string ...
 */
function toExpression(descriptor = createDescriptor()) {
    //
    let result = '';

    //
    // Validate Arg ...
    if (!isDescriptor(descriptor)) {
        return result;
    }

    //
    //#region Imports ...
    if (XValueTools.hasChildArray(descriptor.imports)) {
        //
        const expression = descriptor.imports
            .map(d => XImportDescriptor
                .toExpression(d)
            ).join('\n');

        //
        result += expression + '\n\n';
    }
    //#endregion

    //
    //#region Enums ...
    if (XValueTools.hasChildArray(descriptor.enums)) {
        //
        const expression = descriptor.enums
            .map(d => XEnumDescriptor
                .toExpression(d)
            ).join('\n');

        //
        result += expression + '\n\n';
    }
    //#endregion

    //
    //#region Types ...
    if (XValueTools.hasChildArray(descriptor.types)) {
        //
        const expression = descriptor.types
            .map(d => XTypeDescriptor
                .toExpression(d)
            ).join('\n');

        //
        result += expression + '\n\n';
    }
    //#endregion

    //
    //#region Interfaces ...
    if (XValueTools.hasChildArray(descriptor.interfaces)) {
        //
        const expression = descriptor.interfaces
            .map(d => XInterfaceDescriptor
                .toExpression(d)
            ).join('\n');

        //
        result += expression + '\n\n';
    }
    //#endregion

    //
    //#region Consts ...
    if (XValueTools.hasChildArray(descriptor.consts)) {
        //
        const expression = descriptor.consts
            .map(d => XConstDescriptor
                .toExpression(d)
            ).join('\n');

        //
        result += expression + '\n\n';
    }
    //#endregion

    //
    //#region Classes ...
    if (XValueTools.hasChildArray(descriptor.classes)) {
        //
        const expression = descriptor.classes
            .map(d => XClassDescriptor
                .toExpression(d)
            ).join('\n');

        //
        result += expression + '\n\n';
    }
    //#endregion

    //
    //#region Exports ...
    if (XValueTools.hasChildArray(descriptor.exports)) {
        //
        const expression = descriptor.exports
            .map(d => XExportDescriptor
                .toExpression(d)
            ).join('\n');

        //
        result += expression + '\n\n';
    }
    //#endregion

    //
    if (XValueTools.endsWidth('\n', result)) {
        result = result.substring(0, result.length - 1);
    }

    //
    return result;
}

/**
 * extract all exists XFileDescriptors ...
 * 
 * @param {string} file a file path ...
 * @returns a collection of XFileDescriptors ...
 */
async function extractDescriptor(file = '') {
    //
    let result = createDescriptor();

    //
    if (!XFileTools.isFileExists(file)) {
        return undefined;
    }

    //
    const fileContent = await XFileTools.readFile(file);
    if (!XValueTools.isValidArg(fileContent)) {
        return undefined;
    }

    //
    result = extractDescriptorFromContent(fileContent);
    return result;
}

/**
 * extract all exists XFileDescriptors ...
 * 
 * @param {string} content a file content ...
 * @returns a collection of XFileDescriptors ...
 */
function extractDescriptorFromContent(content = '') {
    //
    // Prepare result ...
    let result = createDescriptor();

    //
    // Validate Args ...
    if (!XValueTools.isValidArg(content)) {
        return undefined;
    }

    //
    const types = XTypeDescriptor.extractDescriptorsFromContent(content);
    const enums = XEnumDescriptor.extractDescriptorsFromContent(content);
    const consts = XConstDescriptor.extractDescriptorsFromContent(content);
    const classes = XClassDescriptor.extractDescriptorsFromContent(content);
    const exports = XExportDescriptor.extractDescriptorsFromContent(content);
    const imports = XImportDescriptor.extractDescriptorsFromContent(content);
    const interfaces = XInterfaceDescriptor.extractDescriptorsFromContent(content);

    //
    result = {
        types,
        enums,
        consts,
        imports,
        exports,
        classes,
        interfaces,
    };

    //
    return result;
}

//
// Module Exports ...
module.exports = {
    //
    isDescriptor,
    toExpression,
    createDescriptor,
    extractDescriptor,
    extractDescriptorFromContent,
}