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
    apiTransUnitRepo        *repositories.ApiTransUnitRepo
}

func NewInitService() InitService {
    return &initService{
        modelObjectRepo:        repositories.NewModelObjectRepo(datasource.InstanceMaster()),
        modelObjectAttrRepo:    repositories.NewModelObjectAttrRepo(datasource.InstanceMaster()),
        apiRepo:                repositories.NewApiRepo(datasource.InstanceMaster()),
        apiTransUnitRepo:       repositories.NewApiTransUnitRepo(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
    }
    
    transList, err2 := s.apiTransUnitRepo.GetAll()
    if err2 != nil {
        return nil
    }
    
    for _, api := range apiList {
        moduleId := api.ModuleId
        apiId    := api.ApiId
        trans := make([]viewmodels.ApiTransUnitInfo, 0)
        for _, tran := range transList{
            if tran.ModuleId == moduleId && tran.ApiId == apiId {
               trans = append(trans, tran)
            }
        }
    
        cacheData := &viewmodels.ApiDataInfo{
            ModuleId:    api.ModuleId,
            ModuleTitle: api.ModuleTitle,
            ApiId:       api.ApiId,
            ApiCode:     api.ApiCode,
            ApiTitle:    api.ApiTitle,
            ApiType:     api.ApiType,
            ApiParams:   api.ApiParams,
            ApiDesc:     api.ApiDesc,
            Status:      api.Status,
            TransUnits:  trans,
        }
    
        // 缓存数据
        err3 := cache.SetApiData(api.ApiCode, cacheData)
        if err3 != nil {
            return errors.New("Redis缓存Api数据失败")
        }
    }
    
    return nil
}

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