/* eslint-disable no-prototype-builtins */

import { checkValidCall } from "./dialog";
import { IUseOptions , IOptions } from "./interfaces";
import { MaskBuilder } from "./MaskBuilder";
import { prepareOptionObject } from "./prepare";

const mb = MaskBuilder.getInstance() as MaskBuilder;

const isSubObject = ( object1: any , object2: any ) => {
	for ( const key in object2 ) {

		// stop if the key exists in the subobject but not in the main object
		if ( object2.hasOwnProperty( key ) && !object1.hasOwnProperty( key ) ) {
			if ( typeof object2.key !== "function" ) {
				return false;
			}
		}
	}
	return true;
};

const fixOptions = <T extends IUseOptions>( object: T , options: IOptions ) => {
	prepareOptionObject( object );

	if ( object.modulopt ) {
		Object.keys( options ).map( ( key: string ) => {
			const value = options[ key ];

			if ( object.options[ key ] === undefined ) {
				checkValidCall( { data : object , key , kind : "options" , value } );
			}

			const handled = isMultiChoiceOptionsHandled( object , key , options );
			if ( !handled ) {

				// handle free options (default is null)
				if ( object.modulopt.defaults[ key ] === null ) {

					// affect a value options[ key ] except if it is undefinied : fallbacks to null;
					object.options[ key ] =
						options[ key ] === undefined ? null : options[ key ];

				} else if (
					typeof object.modulopt.defaults[ key ] === typeof options[ key ]
				) {
					object.options[ key ] = options[ key ];
				} else {

					if( object.modulopt.config.options.mysterious !== "ignore" ){
						
						const refererObj = object.options[ key ];
						const subObj = options[ key ];

						if( !isSubObject( refererObj , subObj ) ) {
							checkValidCall( { data : object , key , kind : "free" , value } );
						}
					}

					if( object.modulopt.config.options.mysteriousAffect ){
						object.options[ key ] = options[ key ];
					}
				}
			}
		} );
	}
};

const isMultiChoiceOptionsHandled = <T extends IUseOptions>(
	object: T ,
	key: string ,
	options: IOptions
): boolean => {
	const multiChoices = object.modulopt.masks[ key ];
	const value = options[ key ];

	if ( multiChoices ) {

		// if the value is one of the multiple choice options
		if ( Object.values( multiChoices ).includes( value ) ) {
			object.options[ key ] = options[ key ];
		} else {
			checkValidCall( { data : object , key , kind : "propositions" , value } );
		}
		return true;
	}
	return false;
};

const stickOptions = <T extends IUseOptions>( object: T , ...options: any ): T => {
	options
		.sort( ( a: any , b: any ) => ( typeof a < typeof b ? 1 : -1 ) )
		.forEach( ( optSet: any ) => {
			if ( typeof optSet === "string" ) {
				object.options = mb.getOptionsFromMask( object.modulopt! , optSet );
			} else if ( typeof optSet === "object" ) {
				fixOptions( object , optSet );
			}
		} );

	return object;
};

export { stickOptions , fixOptions };