import { StandardError } from '../common/error'

import { BaseModel } from '../model'
import { OperaterFactory, IOperater } from './operater'


/**
 * 基类-数据服务
 * 
 * @export
 * @abstract
 * @class BaseProvider
 */
export abstract class BaseProvider<M extends BaseModel, Op extends IOperater<M>> {

    /**
     * 实体
     * 
     * @memberof BaseProvider
     */
    //Model: new (data?: M) => M
    OP: new () => Op
    // constructor(inModel: new (data?: M) => M, inOP: new () => Op) {
    constructor(inOP: new () => Op) {
        //this.Model = inModel
        this.OP = inOP
    }

    /**
     * 新增
     * 
     * @param {M} model 需要信息的实体
     * @returns {(Promise<M | undefined>)} 
     * @memberof BaseProvider
     */
    public async add(model: M): Promise<M | undefined> {
        let instance = OperaterFactory.get<Op, M>(this.OP)
        let dbResult = await instance.create(model)
        return dbResult
    }

    /**
     * 更新
     * 
     * @param {string} id 
     * @param {{ [attr: string]: any }} values 
     * @returns {(Promise<M | undefined>)} 
     * @memberof BaseProvider
     */
    public async update(id: string, values: { [attr: string]: any }): Promise<M | undefined> {
        let instance = OperaterFactory.get<Op, M>(this.OP)
        if (!id) return
        let dbResult = await instance.update(id, values);
        return dbResult
    }

    /**
     * 删除
     * 
     * @param {string} id 
     * @returns {Promise<boolean>} 
     * @memberof BaseProvider
     */
    public async delete(id: string): Promise<boolean> {
        let instance = OperaterFactory.get<Op, M>(this.OP)
        if (!id) return false;
        let dbResult = await instance.delete(id)
        return true
    }

    /**
     * 获取一条数据
     * 
     * @param {string} id 
     * @param {{ [property: string]: any }} [where] 
     * @returns {(Promise<M | undefined>)} 
     * @memberof BaseProvider
     */
    public async loadWhere(where?: { [property: string]: any }): Promise<Array<M>> {
        let instance = OperaterFactory.get<Op, M>(this.OP)
        let dbResult = await instance.loads(where || {})
        let result: Array<M> = [];
        if (dbResult && dbResult.length) {
            dbResult.forEach(element => {
                result.push(element)
            });
        }
        return result
    }

    /**
     * 根据ID获取数据
     * 
     * @param {string} id 
     * @returns 
     * @memberof BaseProvider
     */
    public async load(id: string): Promise<M | undefined> {
        let instance = OperaterFactory.get<Op, M>(this.OP)
        if (!id) return;
        let dbResult = await instance.load(id)
        return dbResult
    }

}