package cache

import (
    "log"
    "xps/cmd/datasource"
)
import modelRepo "xps/pkg/model/repository"
import bizRepo   "xps/pkg/biz/repository"

func InitCacheData() {
    modelObjectToCache()
    bizObjectToCache()
}

func modelObjectToCache() {
    modelObjectRepo     := modelRepo.NewModelObjectRepo(datasource.InstanceMaster())
    modelObjectAttrRepo := modelRepo.NewModelObjectAttrRepo(datasource.InstanceMaster())
    modelObjectOAMRepo  := modelRepo.NewModelObjectOAMRepo(datasource.InstanceMaster())

    modelObjectList, err1 := modelObjectRepo.GetAll()
    if err1 != nil {
        log.Fatal(err1.Error())
        return
    }

    for _, o := range modelObjectList {
        err2 := SetModelObject(o.ObjectCode, &o)
        if err2 != nil {
            log.Fatal(err1.Error())
            return
        }
        modelObjectAttrsToCache(modelObjectAttrRepo, o.ModelId, o.ObjectId)
        modelObjectOAMToCache(modelObjectOAMRepo, o.ModelId, o.ObjectId)
    }
}

func modelObjectAttrsToCache(modelObjectAttrRepo *modelRepo.ModelObjectAttrRepo, modelId, objectId int64) {
    attrList, err1 := modelObjectAttrRepo.GetListById(modelId, objectId)
    if err1 != nil {
        log.Fatal(err1.Error())
        return
    }

    if len(attrList) <= 0 {
        return
    }
    objectCode := attrList[0].ObjectCode
    err2 := SetModelObjectAttrs(objectCode, attrList)
    if err2 != nil {
        log.Fatal(err2.Error())
        return
    }
}

func modelObjectOAMToCache(modelObjectOAMRepo *modelRepo.ModelObjectOAMRepo, modelId, objectId int64) {
    oamList, err1 := modelObjectOAMRepo.GetListById(modelId, objectId)
    if err1 != nil {
        log.Fatal(err1.Error())
        return
    }

    for _, oam := range oamList {
        err2 := SetModelObjectOAM(oam.ObjectCode, oam.OamCode, &oam)
        if err2 != nil {
            log.Fatal(err1.Error())
            return
        }
    }
}

func bizObjectToCache() {
    bizObjectRepo     := bizRepo.NewBizObjectRepo(datasource.InstanceMaster())
    bizObjectAttrRepo := bizRepo.NewBizObjectAttrRepo(datasource.InstanceMaster())
    bizObjectOAMRepo  := bizRepo.NewBizObjectOAMRepo(datasource.InstanceMaster())

    bizObjectList, err1 := bizObjectRepo.GetAll()
    if err1 != nil {
        log.Fatal(err1.Error())
        return
    }

    for _, o := range bizObjectList {
        err2 := SetBizObject(o.ObjectCode, &o)
        if err2 != nil {
            log.Fatal(err1.Error())
            return
        }
        bizObjectAttrsToCache(bizObjectAttrRepo, o.BizId, o.ObjectId)
        bizObjectOAMToCache(bizObjectOAMRepo, o.BizId, o.ObjectId)
    }
}

func bizObjectAttrsToCache(bizObjectAttrRepo *bizRepo.BizObjectAttrRepo, bizId, objectId int64) {
    attrList, err1 := bizObjectAttrRepo.GetListById(bizId, objectId)
    if err1 != nil {
        log.Fatal(err1.Error())
        return
    }

    if len(attrList) <= 0 {
        log.Fatal(err1.Error())
        return
    }
    objectCode := attrList[0].ObjectCode
    err2 := SetBizObjectAttrs(objectCode, attrList)
    if err2 != nil {
        log.Fatal(err2.Error())
        return
    }
}

func bizObjectOAMToCache(bizObjectOAMRepo *bizRepo.BizObjectOAMRepo, bizId, objectId int64) {
    bizObjectOAMRuleRepo     := bizRepo.NewBizObjectOAMRuleRepo(datasource.InstanceMaster())
    bizObjectOAMParamsRepo     := bizRepo.NewBizObjectOAMParamsRepo(datasource.InstanceMaster())
    bizObjectOAMMappingRepo := bizRepo.NewBizObjectOAMMappingRepo(datasource.InstanceMaster())

    oamList, err1 := bizObjectOAMRepo.GetListById(bizId, objectId)
    if err1 != nil {
        log.Fatal(err1.Error())
        return
    }

    for _, oam := range oamList {
        err2 := SetBizObjectOAM(oam.ObjectCode, oam.OamCode, &oam)
        if err2 != nil {
            log.Fatal(err2.Error())
            return
        }
        bizObjectOAMRuleToCache(bizObjectOAMRuleRepo, oam.BizId, oam.ObjectId, oam.OamId, oam.ObjectCode, oam.OamCode)
        bizObjectOAMParamsToCache(bizObjectOAMParamsRepo, oam.BizId, oam.ObjectId, oam.OamId, oam.ObjectCode, oam.OamCode)
        bizObjectOAMMappingToCache(bizObjectOAMMappingRepo, oam.BizId, oam.ObjectId, oam.OamId, oam.ObjectCode, oam.OamCode)
    }
}

func bizObjectOAMRuleToCache(bizObjectOAMRuleRepo *bizRepo.BizObjectOAMRuleRepo, bizId, objectId, oamId int64, objectCode, oamCode string) {
    ruleList, err1 := bizObjectOAMRuleRepo.GetListById(bizId, objectId, oamId)
    if err1 != nil {
        log.Fatal(err1.Error())
        return
    }

    err2 := SetBizObjectOAMRules(objectCode, oamCode, ruleList)
    if err2 != nil {
        log.Fatal(err2.Error())
        return
    }
}

func bizObjectOAMParamsToCache( bizObjectOAMParamsRepo *bizRepo.BizObjectOAMParamsRepo,
                                bizId, objectId, oamId int64,
                                objectCode, oamCode string) {
    params, err1 := bizObjectOAMParamsRepo.GetListById(bizId, objectId, oamId)
    if err1 != nil {
        log.Fatal(err1.Error())
        return
    }

    err2 := SetBizObjectOAMParams(objectCode, oamCode, params)
    if err2 != nil {
        log.Fatal(err2.Error())
        return
    }
}

func bizObjectOAMMappingToCache(bizObjectOAMMappingRepo *bizRepo.BizObjectOAMMappingRepo,
                                bizId, objectId, oamId int64,
                                objectCode, oamCode string) {
    mappingList, err1 := bizObjectOAMMappingRepo.GetListById(bizId, objectId, oamId)
    if err1 != nil {
        log.Fatal(err1.Error())
        return
    }

    err2 := SetBizObjectOAMMapping(objectCode, oamCode, mappingList)
    if err2 != nil {
        log.Fatal(err2.Error())
        return
    }
}