package service

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

type ApiTransUnitService interface {
    GetList(m map[string]interface{}) ([]viewmodels.ApiTransUnitInfo, error)
    GetPage(m map[string]interface{}) (*viewmodels.PageResult, error)
    GetById(moduleId, apiId, atuId int64) (*viewmodels.ApiTransUnitInfo, error)
    Create(d *datamodels.ApiTransUnit) error
    Update(d *datamodels.ApiTransUnit) error
    Delete(m map[string]interface{}) error
    GenerateParams(apiCode string)(map[string]interface{}, error)
}

type apiTransUnitService struct {
    apiRepo *repositories.ApiRepo
    transRepo *repositories.ApiTransUnitRepo
}


func NewApiTransUnitService() ApiTransUnitService {
    return &apiTransUnitService{
        apiRepo: repositories.NewApiRepo(datasource.InstanceMaster()),
        transRepo: repositories.NewApiTransUnitRepo(datasource.InstanceMaster()),
    }
}

func (s *apiTransUnitService) GetList(m map[string]interface{}) ([]viewmodels.ApiTransUnitInfo, error) {
    return s.transRepo.GetList(m)
}

func (s *apiTransUnitService) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
    return s.transRepo.GetPage(m)
}

func (s *apiTransUnitService) GetById(moduleId, apiId, atuId int64) (*viewmodels.ApiTransUnitInfo, error) {
    return s.transRepo.GetById(moduleId, apiId, atuId)
}

func (s *apiTransUnitService) Create(atu *datamodels.ApiTransUnit) error {
    atu.AtuId = NewID()
    err := s.transRepo.Create(atu)
    if err != nil {
        return err
    }
    
    moduleId := atu.ModuleId
    apiId    := atu.ApiId
    return s.CacheApiData(moduleId, apiId)
}

func (s *apiTransUnitService) Update(atu *datamodels.ApiTransUnit) error {
    err := s.transRepo.Update(atu)
    if err != nil {
        return err
    }
    
    moduleId := atu.ModuleId
    apiId    := atu.ApiId
    return s.CacheApiData(moduleId, apiId)
}

func (s *apiTransUnitService) Delete(m map[string]interface{}) error {
    return s.transRepo.Delete(m)
}

func (s *apiTransUnitService) CacheApiData(moduleId, apiId int64) error {
    api, err := s.apiRepo.GetById(moduleId, apiId)
    if err != nil {
        return nil
    }
    
    trans, err := s.transRepo.GetListById(moduleId, apiId)
    if err != nil {
        return nil
    }
    
    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,
    }
    
    // 缓存数据
    err = cache.SetApiData(api.ApiCode, cacheData)
    if err != nil {
        return errors.New("Redis缓存Api数据失败")
    }
    
    return nil
}


func (s *apiTransUnitService) GenerateParams(apiCode string)(map[string]interface{}, error){
    apiInfo, err1 := cache.GetApiData(apiCode)
    if err1 != nil {
        return nil, err1
    }
    
    params := make(map[string]interface{})
    transUnits := apiInfo.TransUnits
    for _, transUnit := range transUnits {
        objectCode := transUnit.ObjectCode
        objectInfo, err2 := cache.GetModelObjectData(objectCode)
        if err2 != nil {
            return nil, err2
        }
        
        attrs := objectInfo.Attrs
        for _, attr := range attrs {
            attrCode := attr.AttrCode
            if _, ok := params[attrCode]; !ok{
                switch attr.AttrType {
                case 1: // int
                   params[attrCode] = 0
                case 2: // string
                    params[attrCode] = "test"
                case 3: // decimal
                    params[attrCode] = 0.01
                case 4: // datetime
                    params[attrCode] = "2020-01-01 10:10:10"
                case 5: // date
                    params[attrCode] = "2020-01-01"
                case 6: // time
                    params[attrCode] = "10:10:10"
                default:
                    params[attrCode] = "NaN"
                }
            }
        }
    }
    
    return params, nil
}