import IBaseModel from '../interface/IBaseModel';
import IBaseModelOptions from '../interface/IBaseModelOptions';
import BaseObject from '../BaseObject';
import Util from '../util/Util';
 
/**
 *  Base Model is a design pattern used to transfer data between software application subsystems.
 *
 * Note: If the data doesn't match the property names you can set the value manually after update super method has been called.
 *  Also in the class you inherit BaseModel from you can override the update method to handle the data how you want.
 *
 * @class BaseModel
 * @extends BaseObject
 * @param [data] {any} Provide a way to update the base model upon initialization.
 * @param [opts] {{ expand:boolean }} Options for the base model.
 * @module StructureJS
 * @submodule model
 * @requires Extend
 * @requires BaseObject
 * @requires Util
 * @constructor
 * @author Robert S. (www.codeBelt.com)
 * @example
 *      // Example how to extend the BaseModel class.
 *      let data = {
 *              make: 'Tesla',
 *              model: 'Model S',
 *              YeAr: 2014,
 *              feature: {
 *                  abs: true,
 *                  airbags: true
 *              }
 *      }
 *      let carModel = new CarModel(data);
 *
 *
 *      // Example how to extend the BaseModel class.
 *      class CarModel extends BaseModel {
 *
 *          // You need to have properties so the data will get assigned.
 *          // If not the data will not get assigned to the model.
 *          make = null;
 *          model = null;
 *          year = null;
 *          allWheel = false; // Set a default value
 *
 *          // You can assign BaseModel to a property which will
 *          // automatically created it and pass the data to it.
 *          feature = FeatureModel
 *
 *          // If you have an array of data and want them assign to a BaseModel.
 *          feature = [FeatureModel];
 *
 *          constructor(data = {}, opts = {}) {
 *              super(opts);
 *
 *              if (data) {
 *                  this.update(data);
 *              }
 *          }
 *
 *          // @overridden BaseModel.update
 *          update(data) {
 *              super.update(data);
 *
 *              // If the data doesn't match the property name.
 *              // You can set the value(s) manually after the update super method has been called.
 *              this.year = data.YeAr;
 *          }
 *      }
 */
class BaseModel extends BaseObject implements IBaseModel
{
    /**
     * This property helps distinguish a BaseModel from other functions.
     *
     * @property IS_BASE_MODEL
     * @type {boolean}
     * @public
     * @static
     * @readonly
     */
    public static readonly IS_BASE_MODEL:boolean = true;
 
    /**
     * @property sjsOptions
     * @type {IBaseModelOptions}}
     * @public
     */
    protected sjsOptions:IBaseModelOptions = {
        expand: false,
    };
 
    constructor(opts:IBaseModelOptions = {})
    {
        super();
 
        this.sjsOptions.expand = opts.expand === true;
    }
 
    /**
     * Provide a way to update the  Base Model.
     *
     * @method update
     * @param [data={}] {any}
     * @public
     * @example
     *     // Example of updating some of the data:
     *     carModel.update({ year: 2015, allWheel: true});
     *
     *     // Of course you can also do it the following way:
     *     carModel.year = 2015;
     *     carModel.allWheel = false;
     */
    public update(data:any = {}):any
    {
        Object
            .keys(this)
            .forEach(propertyName =>
            {
                // Ignore the sjsId property because it is set in the BaseObject constructor and we don't want to update it.
                if (propertyName !== 'sjsId')
                {
                    const propertyData = this[propertyName];
                    const updateData = data[propertyName];
                    const dataToUse = (updateData !== void 0) ? updateData : propertyData;
 
                    this._updatePropertyWithDataPassedIn(propertyName, dataToUse);
                }
            });
 
        return this;
    }
 
    /**
     * Adds the updateData to the property
     *
     * @method _updatePropertyWithDataPassedIn
     * @param propertyName
     * @param updateData
     * @protected
     */
    protected _updatePropertyWithDataPassedIn(propertyName:any, updateData:any):void
    {
        // If the current property on the model is an array and the updateData is an array.
        if ((this[propertyName] instanceof Array === true) && (updateData instanceof Array === true))
        {
            const isPropertyDataValueAnUninstantiatedBaseModel = (typeof this[propertyName][0] === 'function' && this[propertyName][0].IS_BASE_MODEL === true);
            const isUpdateDataValueAnUninstantiatedBaseModel = (typeof updateData[0] === 'function' && updateData[0].IS_BASE_MODEL === true);
 
            if (isPropertyDataValueAnUninstantiatedBaseModel === false)
            {
                this[propertyName] = updateData.map(data => this._updateData(null, data));
            }
            else if (isPropertyDataValueAnUninstantiatedBaseModel === true && isUpdateDataValueAnUninstantiatedBaseModel === false)
            {
                // If the property data is an uninstantiated BaseModel then we assume the update data passed in
                // needs to be create as that BaseModel Class.
                const baseModel = this[propertyName][0];
                this[propertyName] = updateData.map(data => this._updateData(baseModel, data));
            }
            else
            {
                this[propertyName] = [];
            }
        }
        else
        {
            this[propertyName] = this._updateData(this[propertyName], updateData);
        }
    }
 
    /**
     * @method _updateData
     * @param propertyData
     * @param updateData
     * @protected
     */
    protected _updateData(propertyData:any, updateData:any):any
    {
        let returnData:any = null;
 
        if (this.sjsOptions.expand === false && typeof updateData === 'function' && updateData.IS_BASE_MODEL === true)
        {
            // If updateData is a function and has an IS_BASE_MODEL static property then it must be a child model and we need to return null
            // so it cleans up the BaseModel functions on the property.
            // To create empty model(s) pass { expand: true } for the options.
            return null;
        }
 
        if (typeof propertyData === 'function' && propertyData.IS_BASE_MODEL === true && updateData)
        {
            // If the propertyData is an instance of a BaseModel class and has not been created yet.
            // Instantiate it and pass in the updateData to the constructor.
            returnData = new propertyData(updateData, this.sjsOptions);
        }
        else if ((propertyData instanceof BaseModel) === true)
        {
            // If propertyData is an instance of a BaseModel class and has already been created.
            // Call the update method and pass in the updateData.
            returnData = propertyData.update(updateData);
        }
        else if ((updateData instanceof BaseModel) === true)
        {
            returnData = updateData.clone();
        }
        else
        {
            // Else just return the updateData to the property.
            returnData = updateData;
        }
 
        return returnData;
    }
 
    /**
     * Converts the Base Model data into a JSON object and deletes the sjsId property.
     *
     * @method toJSON
     * @returns {any}
     * @public
     * @example
     *     const obj = carModel.toJSON();
     */
    public toJSON():any
    {
        const clone:any = Util.clone(this);
        return Util.deletePropertyFromObject(clone, ['sjsId', 'sjsOptions']);
    }
 
    /**
     * Converts a  Base Model to a JSON string,
     *
     * @method toJSONString
     * @returns {string}
     * @public
     * @example
     *     const str = carModel.toJSONString();
     */
    public toJSONString():string
    {
        return JSON.stringify(this.toJSON());
    }
 
    /**
     * Converts the string json data into an Object and calls the {{#crossLink "BaseModel/update:method"}}{{/crossLink}} method with the converted Object.
     *
     * @method fromJSON
     * @param json {string}
     * @public
     * @example
     *      const str = '{"make":"Tesla","model":"Model S","year":2014}'
     *      const carModel = new CarModel();
     *      carModel.fromJSON(str);
     */
    public fromJSON(json:string):any
    {
        const parsedData:any = JSON.parse(json);
 
        this.update(parsedData);
 
        return this;
    }
 
    /**
     * Create a clone/copy of the  Base Model.
     *
     * @method clone
     * @returns {BaseModel}
     * @public
     * @example
     *     const clone = carModel.clone();
     */
    public clone():BaseModel
    {
        const clonedBaseModel:BaseModel = new (<any>this).constructor(this);
 
        return clonedBaseModel;
    }
 
}
 
export default BaseModel;