package allied_creation_user

import (
	"encoding/json"
	"fmt"
	"net/url"
	"strconv"

	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/log"
)

//RoleSearch 搜索角色列表
func (gateway HttplibAlliedCreationUser) RoleSearch(param ReqRoleSearch) (*DataRoleSearch, error) {
	urlStr := gateway.baseUrL + "/role/search"
	method := "post"
	req := gateway.CreateRequest(urlStr, method)
	//TODO traceID
	log.Logger.Debug("向用户模块请求数据：搜索角色列表。", map[string]interface{}{
		"api":   method + ":" + urlStr,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("搜索角色列表失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取搜索角色列表失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：搜索角色列表。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析搜索角色列表：%w", err)
	}
	var data DataRoleSearch
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

//RoleGet 获取角色
func (gateway HttplibAlliedCreationUser) RoleGet(param ReqRoleGet) (*DataRoleGet, error) {
	urlStr := gateway.baseUrL + "/role/" + strconv.FormatInt(param.RoleId, 10)
	method := "get"
	req := gateway.CreateRequest(urlStr, method)
	//TODO traceID
	log.Logger.Debug("向用户模块请求数据：获取角色。", map[string]interface{}{
		"api":   method + ":" + urlStr,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求获取角色失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取获取角色失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：获取角色。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析获取角色：%w", err)
	}
	var data DataRoleGet
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// RoleAssign 分配角色给多个用户
func (gateway HttplibAlliedCreationUser) RoleAssign(param ReqRoleAssign) (*DataRoleAssign, error) {
	urlStr := gateway.baseUrL + "/role/assign"
	method := "post"
	req := gateway.CreateRequest(urlStr, method)
	log.Logger.Debug("向用户模块请求数据：分配角色给多个用户。", map[string]interface{}{
		"api":   method + ":" + urlStr,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求分配角色给多个用户失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取分配角色给多个用户失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：分配角色给多个用户。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析分配角色给多个用户：%w", err)
	}
	var data DataRoleAssign
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// RoleCreate 创建角色
func (gateway HttplibAlliedCreationUser) RoleCreate(param ReqRoleCreate) (*DataRoleCreate, error) {
	urlStr := gateway.baseUrL + "/role"
	method := "post"
	req := gateway.CreateRequest(urlStr, method)
	log.Logger.Debug("向用户模块请求数据：创建角色。", map[string]interface{}{
		"api":   method + ":" + urlStr,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求创建角色失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取创建角色失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：创建角色。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析创建角色：%w", err)
	}
	var data DataRoleCreate
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// RoleUnassign 取消用户分配的角色
func (gateway HttplibAlliedCreationUser) RoleUnassign(param ReqRoleUnassign) (*DataRoleUnassign, error) {
	urlStr := gateway.baseUrL + "/role/unassign"
	method := "post"
	req := gateway.CreateRequest(urlStr, method)
	log.Logger.Debug("向用户模块请求数据：取消用户分配的角色。", map[string]interface{}{
		"api":   method + ":" + urlStr,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求取消用户分配的角色失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取取消用户分配的角色失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：取消用户分配的角色。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析取消用户分配的角色：%w", err)
	}
	var data DataRoleUnassign
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// RoleUpdate 更新角色
func (gateway HttplibAlliedCreationUser) RoleUpdate(param ReqRoleUpdate) (*DataRoleUpdate, error) {
	urlStr := gateway.baseUrL + "/role/" + strconv.FormatInt(param.RoleId, 10)
	method := "put"
	req := gateway.CreateRequest(urlStr, method)
	log.Logger.Debug("向用户模块请求数据：更新角色。", map[string]interface{}{
		"api":   method + ":" + urlStr,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求更新角色失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取更新角色失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：更新角色。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析更新角色：%w", err)
	}
	var data DataRoleUpdate
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// RoleRemove 移除角色
func (gateway HttplibAlliedCreationUser) RoleRemove(param ReqRoleRemove) (*DataRoleRemove, error) {
	urlStr := gateway.baseUrL + "/role/batch-delete"
	method := "post"
	req := gateway.CreateRequest(urlStr, method)
	log.Logger.Debug("向用户模块请求数据：移除角色。", map[string]interface{}{
		"api":   method + ":" + urlStr,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求移除角色失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取移除角色失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：移除角色。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析移除角色：%w", err)
	}
	var data DataRoleRemove
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// RoleRemove 批量移除角色
func (gateway HttplibAlliedCreationUser) RoleBatchRemove(param ReqRoleBatchRemove) (*DataRoleBatchRemove, error) {
	urlStr := gateway.baseUrL + "/role/batch-delete"
	method := "post"
	req := gateway.CreateRequest(urlStr, method)
	log.Logger.Debug("向用户模块请求数据：批量移除角色。", map[string]interface{}{
		"api":   method + ":" + urlStr,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求批量移除角色失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取批量移除角色失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：批量移除角色。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析批量移除角色：%w", err)
	}
	var data DataRoleBatchRemove
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// RoleGetRelatedUser 获取角色相关联的用户
func (gateway HttplibAlliedCreationUser) RoleGetRelatedUser(param ReqRoleGetRelatedUser) (*DataRoleGetRelatedUser, error) {
	orgId := strconv.FormatInt(param.OrgId, 10)
	departmentId := strconv.FormatInt(param.DepartmentId, 10)
	v := url.Values{}
	v.Set("orgId", orgId)
	v.Set("departmentId", departmentId)
	urlStr := gateway.baseUrL + "/role/" + strconv.FormatInt(param.RoleId, 10) + "/related-user?" + v.Encode()
	method := "get"
	req := gateway.CreateRequest(urlStr, method)
	log.Logger.Debug("向用户模块请求数据：获取角色相关联的用户。", map[string]interface{}{
		"api":   method + ":" + urlStr,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求获取角色相关联的用户失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取获取角色相关联的用户失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：获取角色相关联的用户。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析获取角色相关联的用户：%w", err)
	}
	var data DataRoleGetRelatedUser
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// RoleGetRelatedUser 获取角色相关联的用户
func (gateway HttplibAlliedCreationUser) RoleRelatedUser(param ReqRoleGetRelatedUser) (*DataRoleGetRelatedUser, error) {
	//v := url.Values{}
	urlStr := gateway.baseUrL + "/role/" + strconv.FormatInt(param.RoleId, 10) + "/related-user"
	method := "post"
	req := gateway.CreateRequest(urlStr, method)
	log.Logger.Debug("向用户模块请求数据：获取角色相关联的用户。", map[string]interface{}{
		"api":   method + ":" + urlStr,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求获取角色相关联的用户失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取获取角色相关联的用户失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：获取角色相关联的用户。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析获取角色相关联的用户：%w", err)
	}
	var data DataRoleGetRelatedUser
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// RoleGetAccessMenus 获取角色菜单
func (gateway HttplibAlliedCreationUser) RoleGetAccessMenus(param ReqRoleGetAccessMenus) (*DataRoleGetAccessMenus, error) {
	urlStr := gateway.baseUrL + "/role/" + strconv.FormatInt(param.RoleId, 10) + "/access-menus"
	method := "get"
	req := gateway.CreateRequest(urlStr, method)
	log.Logger.Debug("向用户模块请求数据：获取角色菜单。", map[string]interface{}{
		"api":   method + ":" + urlStr,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求获取角色菜单失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取获取角色菜单失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：获取角色菜单。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析获取角色菜单：%w", err)
	}
	var data DataRoleGetAccessMenus
	err = gateway.GetResponseData(result, &data)
	return &data, err
}

// ReqRoleSetAccessMenus 设置角色菜单
func (gateway HttplibAlliedCreationUser) RoleSetAccessMenus(param ReqRoleSetAccessMenus) (*DataRoleSetAccessMenus, error) {
	urlStr := gateway.baseUrL + "/role/" + strconv.FormatInt(param.RoleId, 10) + "/access-menus"
	method := "put"
	req := gateway.CreateRequest(urlStr, method)
	log.Logger.Debug("向用户模块请求数据：设置角色菜单。", map[string]interface{}{
		"api":   method + ":" + urlStr,
		"param": param,
	})
	req, err := req.JSONBody(param)
	if err != nil {
		return nil, fmt.Errorf("请求设置角色菜单失败：%w", err)
	}

	byteResult, err := req.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取设置角色菜单失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：设置角色菜单。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result service_gateway.GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析设置角色菜单：%w", err)
	}
	var data DataRoleSetAccessMenus
	err = gateway.GetResponseData(result, &data)
	return &data, err
}