package gateway

import (
    "errors"
    "time"
    "xps/cache"
    "xps/constant"
    "xps/datasource"
    "xps/dataway"
    "xps/service"
    "xps/viewmodels"
)

type HttpHandler interface {
    Get(objectCode, oamCode string, params []viewmodels.QueryParam)(map[string]interface{}, error)
    GetPage(objectCode, oamCode string, params []viewmodels.QueryParam, page int, limit int)(*viewmodels.PageResult, error)
    GetList(objectCode, oamCode string, params []viewmodels.QueryParam)([]map[string]interface{}, error)
    
    GenerateParams(objectCode, oamCode string)(map[string]interface{}, error)
    
    Create(objectCode, oamCode string, m map[string]interface{}, user *viewmodels.CurUserInfo)error
    Update(objectCode, oamCode string, m map[string]interface{}, user *viewmodels.CurUserInfo)error
    Patch(objectCode, oamCode string, m map[string]interface{}, user *viewmodels.CurUserInfo)error
    Delete(objectCode, oamCode string, m map[string]interface{}, user *viewmodels.CurUserInfo)error
}

type httpHandler struct {
    xBus *dataway.DatabaseIO
}

func NewHttpHandler() HttpHandler {
    return &httpHandler{
        xBus: dataway.NewDatabaseIO(datasource.InstanceSlave()),
    }
}

func (a *httpHandler) GenerateParams(objectCode, oamCode string) (map[string]interface{}, error) {
    attrs, err2 := cache.GetBizObjectAttrs(objectCode)
    if err2 != nil {
        return nil, err2
    }
    
    result := make(map[string]interface{}, 0)
    for _, attr := range attrs {
        attrType := attr.AttrType
        if attrType == constant.DATA_TYPE_INT {
            result[attr.AttrCode] = 1
        } else if attrType == constant.DATA_TYPE_VARCHAR {
            result[attr.AttrCode] = "test"
        } else if attrType == constant.DATA_TYPE_DECIMAL {
            result[attr.AttrCode] = 1.1
        } else if attrType == constant.DATA_TYPE_DATE {
            result[attr.AttrCode] = "2022-01-01"
        } else if attrType == constant.DATA_TYPE_DATETIME {
            result[attr.AttrCode] = "2022-01-01 01:01:01"
        }
    }
    
    return result, nil
}

func (a *httpHandler) Get(objectCode, oamCode string, params []viewmodels.QueryParam)(map[string]interface{}, error) {
    oam, err1:= cache.GetBizObjectOAM(objectCode, oamCode)
    if err1 != nil {
        return nil, err1
    }
    
    sqlStatement := oam.SqlStatement
    data, err2 := a.xBus.GetById(sqlStatement, params)
    if err2 != nil {
        return nil, err2
    }
    
    return a.Mapping2BizObjectAttr(objectCode, data)
}

func (a *httpHandler) GetList(objectCode, oamCode string, params []viewmodels.QueryParam)([]map[string]interface{}, error) {
    oam, err1:= cache.GetBizObjectOAM(objectCode, oamCode)
    if err1 != nil {
        return nil, err1
    }
    sqlStatement := oam.SqlStatement
    dataList, err2 := a.xBus.GetList(sqlStatement, params)
    if err2 != nil {
        return nil, err2
    }
    return a.Mapping2BizObjectList(objectCode, dataList)
}

func (a *httpHandler) GetPage(objectCode, oamCode string, params []viewmodels.QueryParam, page int, limit int) (*viewmodels.PageResult, error) {
    oam , err1:= cache.GetBizObjectOAM(objectCode, oamCode)
    if err1 != nil {
        return nil, err1
    }
    
    sqlStatement := oam.SqlStatement
    sqlCount     := oam.SqlCount
    pageData, err2 := a.xBus.GetPage(sqlStatement, sqlCount, params, page, limit)
    if err2 != nil {
        return nil, err2
    }
    return a.Mapping2BizPageObject(objectCode, pageData)
}

func (a *httpHandler) Create(objectCode, oamCode string, m map[string]interface{}, user *viewmodels.CurUserInfo) error {
    err1 := a.HandleOAMRuleList(objectCode, oamCode, m, user)
    if err1 != nil {
        return err1
    }
    
    data, err2 := a.Mapping2ModelObjectAttr(objectCode, m)
    if err2 != nil {
        return err2
    }
    
    objectOAMMappingList, err3 := cache.GetBizObjectOAMMapping(objectCode, oamCode)
    if err3 != nil {
        return err3
    }
    for _, mappingObject := range objectOAMMappingList {
        mappingObjectCode := mappingObject.MappingObjectCode
        err4 := a.xBus.Create(mappingObjectCode, data)
        if err4 != nil {
            return err4
        }
    }
    
    return nil
}

func (a *httpHandler) Update(objectCode, oamCode string, m map[string]interface{}, user *viewmodels.CurUserInfo) error {
    err1 := a.HandleOAMRuleList(objectCode, oamCode, m, user)
    if err1 != nil {
        return err1
    }
    
    data, err2 := a.Mapping2ModelObjectAttr(objectCode, m)
    if err2 != nil {
        return err2
    }
    
    objectOAMMappingList, err3 := cache.GetBizObjectOAMMapping(objectCode, oamCode)
    if err3 != nil {
        return err3
    }
    
    for _, mappingObject := range objectOAMMappingList {
        mappingObjectCode := mappingObject.MappingObjectCode
        err4 := a.xBus.Update(mappingObjectCode, data)
        if err4 != nil {
            return err4
        }
    }
    
    return nil
}

func (a *httpHandler) Patch(objectCode, oamCode string, m map[string]interface{}, user *viewmodels.CurUserInfo) error {
    err1 := a.HandleOAMRuleList(objectCode, oamCode, m, user)
    if err1 != nil {
        return err1
    }
    
    data, err2 := a.Mapping2ModelObjectAttr(objectCode, m)
    if err2 != nil {
        return err2
    }
    
    objectOAMMappingList, err3 := cache.GetBizObjectOAMMapping(objectCode, oamCode)
    if err3 != nil {
        return err3
    }
    for _, mappingObject := range objectOAMMappingList {
        mappingObjectCode := mappingObject.MappingObjectCode
        err4 := a.xBus.Patch(mappingObjectCode, data)
        if err4 != nil {
            return err4
        }
    }
    return nil
}

func (a *httpHandler) Delete(objectCode, oamCode string, m map[string]interface{}, user *viewmodels.CurUserInfo) error {
    err1 := a.HandleOAMRuleList(objectCode, oamCode, m, user)
    if err1 != nil {
        return err1
    }
    
    data, err2 := a.Mapping2ModelObjectAttr(objectCode, m)
    if err2 != nil {
        return err2
    }
    
    objectOAMMappingList, err3 := cache.GetBizObjectOAMMapping(objectCode, oamCode)
    if err3 != nil {
        return err3
    }
    
    for _, mappingObject := range objectOAMMappingList {
        mappingObjectCode := mappingObject.MappingObjectCode
        err4 := a.xBus.Delete(mappingObjectCode, data)
        if err4 != nil {
            return err4
        }
    }
    return nil
}

func (a *httpHandler) HandleOAMRuleList(objectCode, oamCode string, m map[string]interface{}, user *viewmodels.CurUserInfo) error {
    oamRules, err1 := cache.GetBizObjectOAMRules(objectCode, oamCode)
    if err1 != nil {
        return err1
    }
    
    for _, oamRule := range oamRules {
       err2 := a.HandleOAMRule(&oamRule, m, user)
       if err2 != nil {
           return err2
       }
    }
    return nil
}

func (a *httpHandler) HandleOAMRule(oamRule *viewmodels.BizObjectOAMRuleInfo, m map[string]interface{}, user *viewmodels.CurUserInfo) error {
    if oamRule.RuleId == constant.BIZ_RULE_NEW_ID {
        m[oamRule.TargetAttrCode] = service.NewID()
    } else if oamRule.RuleId == constant.BIZ_RULE_CUR_DATETIME {
        m[oamRule.TargetAttrCode] = time.Now()
    } else if oamRule.RuleId == constant.BIZ_RULE_CUR_DATE {
        m[oamRule.TargetAttrCode] = time.Now()
    } else if oamRule.RuleId == constant.BIZ_RULE_CUR_USER_ID {
        m[oamRule.TargetAttrCode] = user.UserId
    } else if oamRule.RuleId == constant.BIZ_RULE_CUR_USER_NAME {
        m[oamRule.TargetAttrCode] = user.UserName
    } else if oamRule.RuleId == constant.BIZ_RULE_CUR_USER_POSITION_ID {
        m[oamRule.TargetAttrCode] = user.PositionId
    } else if oamRule.RuleId == constant.BIZ_RULE_CUR_USER_POSITION_NAME {
        m[oamRule.TargetAttrCode] = user.PositionName
    } else if oamRule.RuleId == constant.BIZ_RULE_CUR_USER_GROUP_ID {
        m[oamRule.TargetAttrCode] = user.GroupId
    } else if oamRule.RuleId == constant.BIZ_RULE_CUR_USER_GROUP_NAME {
        m[oamRule.TargetAttrCode] = user.GroupName
    }
    return nil
}

func (a *httpHandler) Mapping2ModelObjectAttr(objectCode string, m map[string]interface{})(map[string]interface{}, error) {
    bizObjectAttrs, err := cache.GetBizObjectAttrs(objectCode)
    if err != nil {
        return nil, err
    }
    
    for _, bzAttr := range bizObjectAttrs {
        bzAttrCode    := bzAttr.AttrCode
        bzMappingCode := bzAttr.MappingCode
        if bzAttrValue, ok := m[bzAttrCode]; ok {
            m[bzMappingCode] = bzAttrValue
            delete(m, bzAttrCode)
        }
    }
    return m, nil
}

func (a *httpHandler) Mapping2BizObjectAttr(objectCode string, m map[string]interface{})(map[string]interface{}, error) {
    bizObjectAttrs, err := cache.GetBizObjectAttrs(objectCode)
    if err != nil {
        return nil, err
    }
    
    params := make(map[string]interface{}, 0)
    for _, bzAttr := range bizObjectAttrs {
        bzAttrCode    := bzAttr.AttrCode
        bzMappingCode := bzAttr.MappingCode
        if bzAttrValue, ok := m[bzMappingCode]; ok {
            params[bzAttrCode] = bzAttrValue
        }
    }
    return params, nil
}


func (a *httpHandler) Mapping2BizObjectList(objectCode string, dataList []map[string]interface{})([]map[string]interface{}, error) {
    bizObjectAttrs, err := cache.GetBizObjectAttrs(objectCode)
    if err != nil {
        return nil, err
    }
    
    targetDataList := make([]map[string]interface{}, 0)
    for _, data := range dataList {
        targetData := make(map[string]interface{}, 0)
        for _, bzAttr := range bizObjectAttrs {
            bzAttrCode    := bzAttr.AttrCode
            bzMappingCode := bzAttr.MappingCode
            if bzAttrValue, ok := data[bzMappingCode]; ok {
                targetData[bzAttrCode] = bzAttrValue
            }
        }
        targetDataList = append(targetDataList, targetData)
    }
    return targetDataList, nil
}

func (a *httpHandler) Mapping2BizPageObject(objectCode string, pageData *viewmodels.PageResult)(*viewmodels.PageResult, error) {
    bizObjectAttrs, err := cache.GetBizObjectAttrs(objectCode)
    if err != nil {
        return nil, err
    }
    
    dataList,ok := pageData.Data.([]map[string]interface{})
    if !ok {
        return nil, errors.New("类型转换错误")
    }
    
    targetDataList := make([]map[string]interface{}, 0)
    for _, data := range dataList {
        targetData := make(map[string]interface{}, 0)
        for _, bzAttr := range bizObjectAttrs {
            bzAttrCode    := bzAttr.AttrCode
            bzMappingCode := bzAttr.MappingCode
            if bzAttrValue, ok := data[bzMappingCode]; ok {
                targetData[bzAttrCode] = bzAttrValue
            }
        }
        targetDataList = append(targetDataList, targetData)
    }
    
    targetPageData := &viewmodels.PageResult{
        Total: pageData.Total,
        PageSize: pageData.PageSize,
        Page: pageData.Page,
        TotalPage: pageData.TotalPage,
        Data: targetDataList,
    }
    
    return targetPageData, nil
}