package service

import (
    "errors"
    "xps/cache"
    "xps/datasource"
    "xps/repositories"
    "xps/viewmodels"
)

type InitService interface {
    CacheObjectData() error
    CacheApiData() error
    CacheDBData() error
}

type initService struct {
    modelObjectRepo         *repositories.ModelObjectRepo
    modelObjectAttrRepo     *repositories.ModelObjectAttrRepo
    apiRepo                 *repositories.ApiRepo
}

func NewInitService() InitService {
    return &initService{
        modelObjectRepo:        repositories.NewModelObjectRepo(datasource.InstanceMaster()),
        modelObjectAttrRepo:    repositories.NewModelObjectAttrRepo(datasource.InstanceMaster()),
        apiRepo:                repositories.NewApiRepo(datasource.InstanceMaster()),
    }
}

func (s *initService) CacheObjectData() error {
    objectList, err1 := s.modelObjectRepo.GetAll()
    if err1 != nil {
        return err1
    }

    attrsList, err2 := s.modelObjectAttrRepo.GetAll()
    if err2 != nil {
        return err2
    }
    
    for _, object := range objectList {
        objectId := object.ObjectId
        
        attrs := make([]viewmodels.ModelObjectAttrInfo, 0)
        for _, attr := range attrsList {
            if attr.ObjectId == objectId {
                attrs = append(attrs, attr)
            }
        }
        
        cacheData := &viewmodels.ModelObjectDataInfo{
            ModelId:     object.ModelId,
            ModelTitle:  object.ModelTitle,
            ObjectId:    object.ObjectId,
            ObjectType:  object.ObjectType,
            ObjectTitle: object.ObjectTitle,
            ObjectCode:  object.ObjectCode,
            Comment:     object.Comment,
            IsFixed:     object.IsFixed,
            Attrs:       attrs,
        }
    
        // 缓存数据
        err3 := cache.SetModelObjectData(object.ObjectCode, cacheData)
        if err3 != nil {
            return errors.New("Redis缓存Object数据失败")
        }
    }
    
    return nil
}

func (s *initService) CacheApiData() error {
    apiList, err1 := s.apiRepo.GetAll()
    if err1 != nil {
        return nil
    }
    
    for _, api := range apiList {
        
        // 缓存数据
        err3 := cache.SetApiData(api.ObjectCode, api.OamCode, &api)
        if err3 != nil {
            return errors.New("Redis缓存Api数据失败")
        }
    }
    
    return nil
}

func (s *initService) CacheDBData() error {
    return nil
}