package upstream

import (
	"context"
	"encoding/json"
	"fmt"
	"git.5iot.com/iotlcm-public/iotlcm-openapi/internal/model"
	"git.5iot.com/iotlcm-public/iotlcm-openapi/internal/service"
	"net/http"
	"time"

	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/net/gclient"
	"github.com/gogf/gf/v2/net/gsvc"
	"github.com/gogf/gf/v2/os/gtime"
)

type sUpstreamChan struct {
}

func setClientTimeout(client *gclient.Client, timeout time.Duration) {
	client.SetTimeout(timeout)
	if transport, ok := client.Transport.(*http.Transport); ok {
		transport.ResponseHeaderTimeout = timeout
	}
}

func NewUpstreamChan() *sUpstreamChan {
	return &sUpstreamChan{}
}

func init() {
	service.RegisterUpstreamChan(NewUpstreamChan())
}

func (s *sUpstreamChan) GetUpstreamChanConfig(ctx context.Context) (output model.UpstreamChanConfig, err error) {
	// 获取配置文件信息
	proxyConfig, err := g.Cfg().Get(ctx, "upstream.proxy")
	if err != nil {
		return output, err
	}
	proxyConfig.Scan(&output)
	return output, nil
}

func (s *sUpstreamChan) getGatewayConfig(ctx context.Context) (output model.UpstreamChanConfig, err error) {
	gatewayConfig, err := g.Cfg().Get(ctx, "upstream.gateway")
	if err != nil {
		return output, err
	}
	gatewayConfig.Scan(&output)
	if output.Address == "" {
		return output, gerror.New("upstream gateway config not found")
	}
	return output, nil
}

type sharedTokenResponse struct {
	Code    int                      `json:"code"`
	Message string                   `json:"message"`
	Data    *sharedTokenResponseData `json:"data"`
}

type sharedTokenResponseData struct {
	ChanAlias         string `json:"chanAlias"`
	ChanKey           string `json:"chanKey"`
	AccessToken       string `json:"accessToken"`
	AccessTokenExpire string `json:"accessTokenExpire"`
}

func (s *sUpstreamChan) GetSharedToken(ctx context.Context, chanKey string) (*model.SharedTokenResult, error) {
	chanConfig, err := s.getGatewayConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.GetSharedToken, get gateway config error %+v", err)
		return nil, gerror.Wrap(err, "获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout)
	url := fmt.Sprintf("http://%s/internal/channel/shared-token", chanConfig.Address)
	resp, err := client.Post(ctx, url, g.Map{"chanKey": chanKey})
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.GetSharedToken, post error %+v, url %s, chanKey %s", err, url, chanKey)
		return nil, gerror.New("请求共享Token失败")
	}
	body := resp.ReadAll()
	var output sharedTokenResponse
	if err = json.Unmarshal(body, &output); err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.GetSharedToken, unmarshal error %+v, url %s, body %s", err, url, body)
		return nil, gerror.New("解析共享Token响应失败")
	}
	if output.Code != 0 {
		if output.Message == "" {
			output.Message = "获取共享Token失败"
		}
		return nil, gerror.New(output.Message)
	}
	if output.Data == nil {
		return nil, gerror.New("共享Token响应数据为空")
	}
	result := &model.SharedTokenResult{
		ChanAlias:   output.Data.ChanAlias,
		ChanKey:     output.Data.ChanKey,
		AccessToken: output.Data.AccessToken,
	}
	if output.Data.AccessTokenExpire != "" {
		if t, parseErr := gtime.StrToTime(output.Data.AccessTokenExpire); parseErr == nil {
			result.AccessTokenExpire = t
		}
	}
	return result, nil
}

// 获取卡基本信息
func (s *sUpstreamChan) QuerySimBasicInfo(ctx context.Context, input *model.SimBasicInfoInput) ([]model.SimBaseRes[model.SimBasicInfoItem], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimBasicInfo, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/query/sim-basic-info", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/query/sim-basic-info")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimBasicInfo, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimBasicInfoOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimBasicInfo, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.QuerySimBasicInfo, query sim basic info error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	var basicInfo []model.SimBaseRes[model.SimBasicInfoItem]
	for _, item := range output.Data {
		if item.Code != 0 {
			g.Log().Debugf(ctx, "sUpstreamChan.QuerySimBasicInfo, query sim basic info error %+v, path %s, params %+v, body %s, ", err, url, input, body)
			continue
		}
		basicInfo = append(basicInfo, item)
	}
	return basicInfo, nil
}

// 查询会话信息
func (s *sUpstreamChan) QuerySimSession(ctx context.Context, input *model.SimSessionInput) ([]model.SimBaseRes[model.SimSessionItem], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimSession, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/query/sim-session", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout)
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/query/sim-session")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimSession, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimSessionOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimSession, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.QuerySimSession, query sim session error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	var session []model.SimBaseRes[model.SimSessionItem]
	for _, item := range output.Data {
		if item.Code != 0 {
			g.Log().Debugf(ctx, "sUpstreamChan.QuerySimSession, query sim session error %+v, path %s, params %+v, body %s, ", err, url, input, body)
			continue
		}
		session = append(session, item)
	}
	return session, nil
}

// 查询状态
func (s *sUpstreamChan) QuerySimCardStatus(ctx context.Context, input *model.SimCardStatusInput) ([]model.SimBaseRes[model.SimCardStatusItem], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimCardStatus, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/query/sim-card-status", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/query/sim-status")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimCardStatus, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimCardStatusOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimCardStatus, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.QuerySimCardStatus, query sim card status error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	var cardStatus []model.SimBaseRes[model.SimCardStatusItem]
	for _, item := range output.Data {
		if item.Code != 0 {
			g.Log().Debugf(ctx, "sUpstreamChan.QuerySimCardStatus, query sim card status error %+v, path %s, params %+v, body %s, ", err, url, input, body)
			continue
		}
		cardStatus = append(cardStatus, item)
	}
	return cardStatus, nil
}

// 查询IMEI
func (s *sUpstreamChan) QuerySimImei(ctx context.Context, input *model.SimImeiInput) ([]model.SimBaseRes[model.SimImeiItem], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimImei, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/query/sim-imei", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/query/sim-imei")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimImei, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimImeiOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimImei, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.QuerySimImei, query sim imei error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	var imei []model.SimBaseRes[model.SimImeiItem]
	for _, item := range output.Data {
		if item.Code != 0 {
			g.Log().Debugf(ctx, "sUpstreamChan.QuerySimImei, query sim imei error %+v, path %s, params %+v, body %s, ", err, url, input, body)
			continue
		}
		imei = append(imei, item)
	}
	return imei, nil
}

// 查询流量
func (s *sUpstreamChan) QuerySimDatausage(ctx context.Context, input *model.SimDataUsageInput) ([]model.SimBaseRes[model.SimDataUsageItem], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimDataUsage, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/query/sim-datausage", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/query/sim-datausage")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimDataUsage, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimDataUsageOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimDataUsage, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.QuerySimDataUsage, query sim data usage error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	var dataUsage []model.SimBaseRes[model.SimDataUsageItem]
	for _, item := range output.Data {
		if item.Code != 0 {
			g.Log().Debugf(ctx, "sUpstreamChan.QuerySimDataUsage, query sim datausage error %+v, path %s, params %+v, body %s, ", err, url, input, body)
			continue
		}
		dataUsage = append(dataUsage, item)
	}
	return dataUsage, nil
}

// 查询月流量
func (s *sUpstreamChan) QuerySimDatausageMonthly(ctx context.Context, input *model.SimDataUsageMonthlyInput) ([]model.SimBaseRes[model.SimDataUsageMonthlyOutputItem], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimDatausageMonthly, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/query/sim-datausage-monthly", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	g.Log().Debug(ctx, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	setClientTimeout(client, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/query/sim-datausage-monthly")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimDatausageMonthly, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimDataUsageMonthlyOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimDatausageMonthly, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.QuerySimDatausageMonthly, query sim datausage monthly error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	var dataUsage []model.SimBaseRes[model.SimDataUsageMonthlyOutputItem]
	for _, item := range output.Data {
		if item.Code != 0 {
			g.Log().Debugf(ctx, "sUpstreamChan.QuerySimDatausageMonthly, query sim datausage monthly error %+v, path %s, params %+v, body %s, ", err, url, input, body)
			continue
		}
		dataUsage = append(dataUsage, item)
	}
	return dataUsage, nil
}

// 查询日流量
func (s *sUpstreamChan) QuerySimDatausageDaily(ctx context.Context, input *model.SimDataUsageDailyInput) ([]model.SimBaseRes[model.SimDataUsageDailyOutputItem], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimDatausageDaily, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/query/sim-datausage-daily", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/query/sim-datausage-daily")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimDatausageDaily, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimDataUsageDailyOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimDatausageDaily, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.QuerySimDatausageDaily, query sim datausage daily error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	var dataUsage []model.SimBaseRes[model.SimDataUsageDailyOutputItem]
	for _, item := range output.Data {
		if item.Code != 0 {
			g.Log().Debugf(ctx, "sUpstreamChan.QuerySimDatausageDaily, query sim datausage daily error %+v, path %s, params %+v, body %s, ", err, url, input, body)
			continue
		}
		dataUsage = append(dataUsage, item)
	}
	return dataUsage, nil
}

// 查询已开通APN信息
func (s *sUpstreamChan) QuerySimApnInfo(ctx context.Context, input *model.SimApnInfoInput) ([]model.SimBaseRes[model.SimApnInfoItemList], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimApnInfo, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/query/sim-apn-info", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/query/sim-apn-info")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimApnInfo, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimApnInfoOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimApnInfo, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.QuerySimApnInfo, query sim apn info error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	var apnInfo []model.SimBaseRes[model.SimApnInfoItemList]
	for _, item := range output.Data {
		if item.Code != 0 {
			g.Log().Debugf(ctx, "sUpstreamChan.QuerySimApnInfo, query sim apn info error %+v, path %s, params %+v, body %s, ", err, url, input, body)
			continue
		}
		apnInfo = append(apnInfo, item)
	}
	return apnInfo, nil
}

// 卡状态变更
func (s *sUpstreamChan) ChangeSimStatus(ctx context.Context, input *model.SimCardStatusChangeInput) ([]model.SimBaseRes[model.SimCardStatusChangeItem], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.ChangeSimStatus, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/change/sim-status", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/change/sim-status")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.ChangeSimStatus, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimCardStatusChangeOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.ChangeSimStatus, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.ChangeSimStatus, change sim status error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	var statusList []model.SimBaseRes[model.SimCardStatusChangeItem]
	for _, item := range output.Data {
		if item.Code != 0 {
			g.Log().Debugf(ctx, "sUpstreamChan.ChangeSimStatus, change sim status error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		}
		statusList = append(statusList, item)
	}
	return statusList, nil
}

// 卡APN功能开停
func (s *sUpstreamChan) ChangeSimApnFunction(ctx context.Context, input *model.SimCardOperateChangeApnInput) ([]model.SimBaseRes[model.SimCardOperateChangeApnItem], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.ChangeSimApnFunction, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/query/sim-apn", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/query/sim-apn")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.ChangeSimApnFunction, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimCardOperateChangeApnOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.ChangeSimApnFunction, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.ChangeSimApnFunction, change sim apn function error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	var statusList []model.SimBaseRes[model.SimCardOperateChangeApnItem]
	for _, item := range output.Data {
		if item.Code != 0 {
			g.Log().Debugf(ctx, "sUpstreamChan.ChangeSimApnFunction, change sim apn function error %+v, path %s, params %+v, body %s, ", err, url, input, body)
			continue
		}
		statusList = append(statusList, item)
	}
	return statusList, nil
}

// 查询机卡绑定状态
func (s *sUpstreamChan) QuerySimCardBindStatus(ctx context.Context, input *model.SimCardBindStatusInput) ([]model.SimBaseRes[model.SimCardBindStatusItem], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimCardBindStatus, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/query/sim-card-bind-status", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/query/sim-card-bind-status")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimCardBindStatus, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimCardBindStatusOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimCardBindStatus, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.QuerySimCardBindStatus, query sim card bind status error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	return output.Data, nil
}

// 查询设备状态
func (s *sUpstreamChan) QuerySimDeviceStatus(ctx context.Context, input *model.SimDeviceStatusInput) ([]model.SimBaseRes[model.SimDeviceStatusItem], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimDeviceStatus, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/query/sim-device-status", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/query/sim-device-status")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimDeviceStatus, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimDeviceStatusOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimDeviceStatus, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.QuerySimDeviceStatus, query sim device status error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	return output.Data, nil
}

// 查询地域限制状态
func (s *sUpstreamChan) QuerySimRegionLimitStatus(ctx context.Context, input *model.SimRegionLimitStatusInput) ([]model.SimBaseRes[model.SimRegionLimitStatusItem], error) {
	chanConfig, err := s.GetUpstreamChanConfig(ctx)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimRegionLimitStatus, get upstream chan config error %+v, path %s, input %+v, ", err, "/sim/query/sim-region-limit-status", input)
		return nil, gerror.New("获取上游通道配置失败")
	}
	client := g.Client()
	client.SetDiscovery(gsvc.GetRegistry())
	setClientTimeout(client, chanConfig.Timeout*time.Duration(len(input.SimKeys)))
	url := fmt.Sprintf("http://%s%s", chanConfig.Address, "/sim/query/sim-region-limit-status")
	resp, err := client.Post(ctx, url, input)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimRegionLimitStatus, post error %+v,url %s, params %+v, ", err, url, input)
		return nil, gerror.New("请求失败")
	}
	body := resp.ReadAll()
	output := model.SimRegionLimitStatusOutput{}
	err = json.Unmarshal([]byte(body), &output)
	if err != nil {
		g.Log().Errorf(ctx, "sUpstreamChan.QuerySimRegionLimitStatus, unmarshal error %+v,url %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New("解析响应失败")
	}
	if output.Code != 0 {
		g.Log().Debugf(ctx, "sUpstreamChan.QuerySimRegionLimitStatus, query sim region limit status error %+v, path %s, params %+v, body %s, ", err, url, input, body)
		return nil, gerror.New(output.Message)
	}
	return output.Data, nil
}