package service_gateway

import (
	"encoding/json"
	"fmt"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/constant"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/service_gateway/translator"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/log"
	"strconv"
	"strings"
	"time"
)

type HttplibUserServiceGateway struct {
	httplibBaseServiceGateway
}

// GetUser 获取用户
func (serviceGateway *HttplibUserServiceGateway) GetUser(companyId int64, orgId int64, uid int64) (*translator.UserDetail, error) {
	uidStr := strconv.FormatInt(uid, 10)
	url := serviceGateway.baseURL + "/user/" + uidStr
	request := serviceGateway.createRequest(url, "get")
	options := make(map[string]interface{})
	_, err1 := request.JSONBody(options)
	if err1 != nil {
		return nil, err1
	}
	byteResult, err := request.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取获取用户失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：获取用户。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析获取用户：%w", err)
	}
	var data translator.UserDetail
	err = serviceGateway.getResponseData(result, &data)
	return &data, err
}

// GetUsers 获取用户
func (serviceGateway *HttplibUserServiceGateway) GetUsers(companyId int64, orgId int64, uids []int64) (map[string]interface{}, error) {
	companyIdStr := strconv.FormatInt(companyId, 10)
	url := strings.Join([]string{serviceGateway.baseURL, "user/" + companyIdStr + "/users/get-user"}, "/")
	request := serviceGateway.createRequest(url, "get")
	options := make(map[string]interface{})
	options["uids"] = uids
	_, err1 := request.JSONBody(options)
	if err1 != nil {
		return nil, err1
	}
	response := make(map[string]interface{})
	err2 := request.ToJSON(&response)
	if err2 != nil {
		return nil, err2
	}
	data, err := serviceGateway.responseHandle(response)
	return data, err
}

// GetCompany 获取公司信息
func (serviceGateway *HttplibUserServiceGateway) GetCompany(companyId int64) (*translator.CompanyDetail, error) {
	companyIdStr := strconv.FormatInt(companyId, 10)
	url := serviceGateway.baseURL + "/company/" + companyIdStr
	request := serviceGateway.createRequest(url, "get")
	options := make(map[string]interface{})
	_, err1 := request.JSONBody(options)
	if err1 != nil {
		return nil, err1
	} else {
		log.Logger.Debug("向用户模块请求数据：返回企业。", map[string]interface{}{
			"api":   "get:" + url,
			"param": options,
		})
	}
	byteResult, err := request.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取返回企业失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：返回企业。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析返回企业：%w", err)
	}
	var data translator.CompanyDetail
	err = serviceGateway.getResponseData(result, &data)
	return &data, err
}

// GetDepartment 获取部门信息
func (serviceGateway *HttplibUserServiceGateway) GetDepartment(companyId int64, departmentId int64) (map[string]interface{}, error) {
	companyIdStr := strconv.FormatInt(companyId, 10)
	url := strings.Join([]string{serviceGateway.baseURL, "companies/" + companyIdStr}, "/")
	request := serviceGateway.createRequest(url, "get")
	options := make(map[string]interface{})
	options["departmentId"] = departmentId
	_, err1 := request.JSONBody(options)
	if err1 != nil {
		return nil, err1
	}
	response := make(map[string]interface{})
	err2 := request.ToJSON(&response)
	if err2 != nil {
		return nil, err2
	}
	data, err := serviceGateway.responseHandle(response)
	return data, err
}

// GetOrganization 获取组织信息
func (serviceGateway *HttplibUserServiceGateway) GetOrganization(companyId int64, organizationId int64) (*translator.OrganizationDetail, error) {
	organizationIdStr := strconv.FormatInt(organizationId, 10)
	url := serviceGateway.baseURL + "/org/" + organizationIdStr
	request := serviceGateway.createRequest(url, "get")
	options := make(map[string]interface{})
	_, err1 := request.JSONBody(options)
	if err1 != nil {
		return nil, err1
	}
	byteResult, err := request.Bytes()
	if err != nil {
		return nil, fmt.Errorf("获取返回组织失败：%w", err)
	}
	log.Logger.Debug("获取用户模块请求数据：返回组织。", map[string]interface{}{
		"result": string(byteResult),
	})
	var result GatewayResponse
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return nil, fmt.Errorf("解析返回组织：%w", err)
	}
	var data translator.OrganizationDetail
	err = serviceGateway.getResponseData(result, &data)
	return &data, err
}

// UserInMenu 判断用户是否具有模块权限
func (serviceGateway *HttplibUserServiceGateway) UserInMenu(companyId int64, userId int64, menuCode string) (bool, error) {
	url := strings.Join([]string{serviceGateway.baseURL, "users/menu"}, "/")
	request := serviceGateway.createRequest(url, "get")
	options := make(map[string]interface{})
	options["code"] = menuCode
	_, err1 := request.JSONBody(options)
	if err1 != nil {
		return false, err1
	}
	response := make(map[string]interface{})
	err2 := request.ToJSON(&response)
	if err2 != nil {
		return false, err2
	}
	data, err := serviceGateway.responseHandle(response)
	if data["code"] == 200 {
		return true, nil
	}
	return false, err
}

// UserInOrganization 判断用户是否存在组织内
func (serviceGateway *HttplibUserServiceGateway) UserInOrganization(companyId int64, orgId int64, userId int64) (bool, error) {
	url := strings.Join([]string{serviceGateway.baseURL, "users/menu"}, "/")
	request := serviceGateway.createRequest(url, "get")
	options := make(map[string]interface{})
	options["orgId"] = orgId
	_, err1 := request.JSONBody(options)
	if err1 != nil {
		return false, err1
	}
	response := make(map[string]interface{})
	err2 := request.ToJSON(&response)
	if err2 != nil {
		return false, err2
	}
	data, err := serviceGateway.responseHandle(response)
	if data["code"] == 200 {
		return true, nil
	}
	return false, err
}

func NewHttplibUserServiceGateway() *HttplibUserServiceGateway {
	return &HttplibUserServiceGateway{
		httplibBaseServiceGateway: httplibBaseServiceGateway{
			baseURL:          constant.USER_MODULE_HOST,
			connectTimeout:   100 * time.Second,
			readWriteTimeout: 30 * time.Second,
		},
	}
}