/**
 * 该文件为底层数据操作逻辑  里面尽量不调用Base之外的其他代码
 */


import BaseFunc from "../base/func";
import BaseSupport from "../base/support";

import Realm from 'realm';
import BaseDefine from '../base/define';

import { IbaseFaceObject, IstructBaseKey, IstructDataItem, IstructLogInfo, IstructSystemVariable, IstructFormData, IvalueFormData, IDataDetail } from "../aim/face";
import { IformQueryConfig } from "../aim/form";


type systemVarType = "wait_for_sync" | "sync_timestamp" | "sync_http_sign" | "wait_image_sync";






const RealmDefine = {
    /**
     * 定义数据主键名称 该字段不能修改
     */
    keyName: 'zzzkey',

    /**
     * 数据结构的前缀定义 如果修改会导致所有数据读取不到的 不能修改
     */
    schemaStart: 'R_N_',
    /**
     * 结构的数据类型定义为字符串
     */
    schemaString: 'string'


}



class CdataTopRealm {

    _currentRealm: Realm

    bFlagInit = false

    schemaList: Realm.ObjectSchema[] = []


    addSchema(oSchema) {


        this.schemaList.push(oSchema);


    }

    initSchema() {
        //这里是兼容jest的测试逻辑代码  在测试逻辑代码中，需要require自己
        if (Realm == undefined) {
            var RealmTest = require('realm');
            RealmTest.defaultPath = "./logs/realm/realm_test";


            this._currentRealm = new RealmTest({ schema: this.schemaList });
        }
        else {

            this._currentRealm = new Realm({ schema: this.schemaList });
        }
    }

    upRealm() {
        if (!this.bFlagInit) {

            this.initSchema();

        }
        return this._currentRealm;
    }

    /**
     * 高端操作  一般请勿调用
     * 
     * @param {number} iType 
     * @returns 
     * 
     * @memberOf CRealm
     */
    dangerOperate(iType: number) {

        switch (iType) {
            case 3:
                this.upRealm().close();
                break;
            case 5:
                this.upRealm().deleteAll();
                break;
        }

        return true;
    }

}


const topRealm: CdataTopRealm = new CdataTopRealm();

abstract class CSuperData<T extends IstructBaseKey> {

    _upCurrentRealm() {
        return topRealm.upRealm();
    }

    /**
     * 该方法谨慎调用 返回最高顶级对象
     * 
     * @returns 
     * 
     * @memberOf CSuperData
     */
    warnTopRealm() {
        return topRealm;
    }

    constructor() {

        topRealm.addSchema(this.rootSchemaDefine());
    }



    deleteByKey(sKey: string): boolean {
        this._upCurrentRealm().write(() => {

            let book = this._upCurrentRealm().create(this.rootSchemaNameSpace(), { zzzkey: sKey }, true);
            this._upCurrentRealm().delete(book);
        });

        return true;

    }

    rootDangerClear() {


        this._upCurrentRealm().write(() => {
            let dogs = this._upCurrentRealm().objects<T>(this.rootSchemaNameSpace());
            this._upCurrentRealm().delete(dogs);
        });

    }

    rootWriteItemValue(aVal: T[]): boolean {

        this._upCurrentRealm().write(() => {
            for (var i = 0, j = aVal.length; i < j; i++) {
                this._upCurrentRealm().create(this.rootSchemaNameSpace(), aVal[i], true);
            }

        });

        return true;
    }

    rootUpValueByKey(sKey: string): T {
        let dogs = this.rootReadItemsByFilter(RealmDefine.keyName + ' == "' + sKey + '"');
        let oReturn: T = undefined;
        if (dogs != undefined && dogs.length > 0) {

            oReturn = dogs[0];
        }

        return oReturn;

    }

    rootReadItemsByFilter(sFiter: string): Realm.Collection<T> {
        let dogs = this._upCurrentRealm().objects<T>(this.rootSchemaNameSpace()).filtered(sFiter);
        return dogs;
    }

    abstract rootSchemaDefine()

    abstract rootSchemaNameSpace(): string

    abstract inValue(sKey: string, oValue: any): boolean

}

class CformData extends CSuperData<IstructFormData> {

    rootSchemaNameSpace() {
        return RealmDefine.schemaStart + 'FormData';
    }

    rootSchemaDefine() {


        let prop: IstructFormData = {
            zzzkey: RealmDefine.schemaString,
            formCode: RealmDefine.schemaString,
            createTime: RealmDefine.schemaString,
            updateTime: RealmDefine.schemaString,
            dataState: RealmDefine.schemaString,
            dataTimestamp: RealmDefine.schemaString,
            serverCode: RealmDefine.schemaString,
            clientTimestamp: RealmDefine.schemaString,
            leaderCode: RealmDefine.schemaString,
            clientState: RealmDefine.schemaString,
            jsonData: RealmDefine.schemaString,
            createUser: RealmDefine.schemaString
        }

        return {
            name: this.rootSchemaNameSpace(),
            primaryKey: RealmDefine.keyName,
            properties: prop
        }
    }

    inValue(sKey: string, oFormData: IvalueFormData) {


        if (BaseFunc.stringIsEmpty(sKey)) {
            sKey = BaseSupport.upUuid();
        }

        let oExist = this.rootUpValueByKey(sKey);
        let bFlagExist = oExist !== undefined;

        let oItem: IstructFormData = null;


        if (bFlagExist) {


            oItem = {
                zzzkey: sKey,
                updateTime: BaseSupport.upDate(),
                clientTimestamp: BaseSupport.upNowTimeStamp()

            }

            if (oFormData.value != undefined) {
                oItem.jsonData = JSON.stringify(oFormData.value);
            }


        } else {

            oItem = {
                zzzkey: sKey,
                formCode: oFormData.formCode,
                leaderCode: oFormData.leaderCode == undefined ? '' : oFormData.leaderCode,
                createTime: BaseSupport.upDate(),
                updateTime: '',
                clientTimestamp: BaseSupport.upNowTimeStamp(),
                createUser: '',
                clientState: BaseFunc.stringEmptyDefault(oFormData.clientState, "1"),
                dataState: BaseFunc.stringEmptyDefault(oFormData.dataState, "1"),
                dataTimestamp: BaseFunc.stringEmptyDefault(oFormData.dataTimestamp, ''),
                serverCode: BaseFunc.stringEmptyDefault(oFormData.serverCode, ''),
                jsonData: oFormData.value == undefined ? (bFlagExist ? oExist.jsonData : '') : JSON.stringify(oFormData.value),
            }
        }



        return this.rootWriteItemValue([oItem]);
    }



    changeStateByKey(sKey: string, sState: string): boolean {
        let bFlag = true;

        let oItem = this.rootUpValueByKey(sKey);
        if (oItem != undefined) {
            let oNew: IstructFormData = {
                zzzkey: sKey,
                clientState: sState,
                clientTimestamp: BaseSupport.upNowTimeStamp()
            };

            //如果状态码标记为删除  则将服务端状态标记也标记为删除
            if (sState === "410") {
                oNew.dataState = sState;
            }


            bFlag = this.rootWriteItemValue([oNew]);
        }



        return bFlag;
    }



    /**
     * 标记删除
     * 
     * @param {string} sKey 
     * @returns {boolean} 
     * 
     * @memberof CformData
     */
    outValueByKey(sKey: string): boolean {

        return this.changeStateByKey(sKey, "410");

    }

    /**
     * 根据key获取值
     * 
     * @param {string} sFormCode 
     * @param {string} sKey 
     * @returns {IDataDetail} 
     * 
     * @memberof CformData
     */
    upFormDataByKey(sFormCode: string, sKey: string): IDataDetail {
        return this.upFormData(sFormCode, { key: sKey })[0];

    }



    /**
     * 获取form的数据  注意 这里获取的是格式后的可展示的数据
     * 
     * @param {string} sFormCode 
     * @param {any} [oConfig] 
     * @returns {IDataDetail[]} 
     * 
     * @memberOf CformData
     */
    upFormData(sFormCode: string, oConfig?: IformQueryConfig): IDataDetail[] {

        let oDefault: IformQueryConfig = {

            //排序字段 默认倒序修改时间
            sort: 'clientTimestamp'
        };
        if (oConfig != undefined) {
            oDefault = Object.assign(oDefault, oConfig);
        }

        let oDataResult = this.upDataQuery(sFormCode, oDefault);
        let oReturn: IDataDetail[] = [];
        oDataResult.forEach(
            (fItem) => {


                let oDetail: IDataDetail = {
                    data: JSON.parse(fItem.jsonData),
                    key: fItem.zzzkey,
                    detailLeader:fItem.leaderCode,
                    createTime: fItem.createTime
                }

                oReturn.push(oDetail);
            }
        )

        return oReturn;

    }


    upDataQuery(sFormCode: string, oConfig?: IformQueryConfig): Realm.Collection<IstructFormData> {

        let sIn = 'formCode="' + sFormCode + '" and dataState=="1" and clientState BEGINSWITH "1" ';

        let oDefault: IformQueryConfig = {
            //查询条件
            filter: '',
            //查询数据
            key: '',
            //排序字段 默认倒序修改时间
            sort: ''
        };
        if (oConfig != undefined) {
            oDefault = Object.assign(oDefault, oConfig);
        }
        if (!BaseFunc.stringIsEmpty(oDefault.key)) {
            sIn = sIn + ' and ' + RealmDefine.keyName + '="' + oDefault.key + '" ';
        }

        if (!BaseFunc.stringIsEmpty(oDefault.filter)) {
            sIn = sIn + ' and ' + oDefault.filter;
        }



        let oDataResult = this.rootReadItemsByFilter(sIn);

        if (!BaseFunc.stringIsEmpty(oDefault.sort)) {
            oDataResult = oDataResult.sorted(oDefault.sort, true);
        }
        /*
        let oReturn = [];
        oDataResult.forEach(
            (fItem) => {

                oReturn.push(fItem);
            }
        )
        */

        return oDataResult;
    }



}

class CsystemVariable extends CSuperData<IstructSystemVariable> {


    rootSchemaNameSpace() {
        return RealmDefine.schemaStart + 'SystemVariable';
    }

    rootSchemaDefine() {

        let prop: IstructSystemVariable = {
            zzzkey: RealmDefine.schemaString,
            jsonData: RealmDefine.schemaString,
            updateTime: RealmDefine.schemaString
        }

        return {
            name: this.rootSchemaNameSpace(),
            primaryKey: RealmDefine.keyName,
            properties: prop
        }
    }



    inValue(sKey: string, oVal) {
        let oItem: IstructSystemVariable = {
            zzzkey: sKey,
            jsonData: JSON.stringify(oVal),
            updateTime: BaseSupport.upDate()
        }

        return this.rootWriteItemValue([oItem]);
    }





    upValue<X>(sKey): X {


        let dog = this.rootUpValueByKey(sKey);

        let oReturn: X = undefined;
        if (dog != undefined) {
            oReturn = JSON.parse(dog.jsonData);
        }


        return oReturn;
    }

}

class CdataItem extends CSuperData<IstructDataItem> {
    rootSchemaNameSpace() {
        return RealmDefine.schemaStart + 'DataItem';
    }

    rootSchemaDefine() {
        let prop: IstructDataItem = {
            zzzkey: RealmDefine.schemaString,
            text: RealmDefine.schemaString,
            parent: RealmDefine.schemaString,
            enable: RealmDefine.schemaString
        }
        return {
            name: this.rootSchemaNameSpace(),
            primaryKey: RealmDefine.keyName,
            properties: prop
        }
    }

    initDataItem(oData): boolean {

        let items = [];


        for (var p in oData) {
            var oVal: string = oData[p];

            let sPleft = p.split('_')[0];

            var sFather = sPleft.substr(0, sPleft.length - 4);

            let oItem: IstructDataItem = {
                zzzkey: p,
                text: oVal,
                parent: sFather,
                enable: '1'
            }

            items.push(oItem);


        }


        return this.rootWriteItemValue(items);
    }


    inValue(sKey: string, oVal) {
        var sFather = sKey.substr(0, sKey.length - 4);
        let oItem: IstructDataItem = {
            zzzkey: sKey,

            text: oVal, parent: sFather,
            enable: '1'
        }


        return this.rootWriteItemValue([oItem]);

    }

    upValue(sFatherItemCode) {


        let saveData = this.rootReadItemsByFilter('parent == "' + sFatherItemCode + '"');
        let oReturn = {};
        saveData.forEach((element) => {
            oReturn[element.zzzkey] = element.text
        });
        return oReturn;

    }

}



class ClogInfo extends CSuperData<IstructLogInfo> {
    rootSchemaNameSpace() {
        return RealmDefine.schemaStart + 'LogInfo';
    }

    rootSchemaDefine() {
        let prop: IstructLogInfo = {
            zzzkey: RealmDefine.schemaString,


            dateTime: RealmDefine.schemaString,
            logType: RealmDefine.schemaString,
            logCode: RealmDefine.schemaString,
            logInfo: RealmDefine.schemaString,
        }
        return {
            name: this.rootSchemaNameSpace(),
            primaryKey: RealmDefine.keyName,
            properties: prop
        }
    }




    inValue(sKey: string, oVal: IstructLogInfo[]) {



        return this.rootWriteItemValue(oVal);

    }



    upValue(sKey) {


        return this.rootUpValueByKey(sKey);

    }

}


//const currentOperate = new CRealm();

export default class {


    static dataItem = new CdataItem();

    static systemVariable = new CsystemVariable();

    static formData = new CformData();


    static logInfo = new ClogInfo();



    static dangerClearAll() {
        topRealm.dangerOperate(5);
    }



    static upSystemVar<X>(sKey: systemVarType): X {

        return this.systemVariable.upValue<X>(BaseDefine.upPlusDefine().systemVarStart + sKey);
    }

    static inSystemVar<X>(sKey: systemVarType, oValue: X): boolean {

        return this.systemVariable.inValue(BaseDefine.upPlusDefine().systemVarStart + sKey, oValue);
    }


}