package upstreamapi

import (
	"context"
	"time"
	"git.5iot.com/iotlcm-public/iotlcm-upstream-chan/internal/consts"
	"git.5iot.com/iotlcm-public/iotlcm-upstream-chan/internal/model"
)

func (u *sUpstreamAPI) QuerySimCardStatusBatch(ctx context.Context, input *model.SimCardStatusInput) (output model.SimCardStatusOutput, err error) {
	return u.queryStatusBatch(ctx, input)
}

func (u *sUpstreamAPI) QuerySimDataUsageMonthlyBatch(ctx context.Context, input *model.SimDataUsageMonthlyInput) (output model.SimDataUsageMonthlyOutput, err error) {
	return u.queryMonthlyBatch(ctx, input)
}

func (u *sUpstreamAPI) QuerySimDataUsageDailyBatch(ctx context.Context, input *model.SimDataUsageDailyInput) (output model.SimDataUsageDailyOutput, err error) {
	return u.queryDailyBatch(ctx, input)
}

func (u *sUpstreamAPI) queryStatusBatch(ctx context.Context, input *model.SimCardStatusInput) (output model.SimCardStatusOutput, err error) {
	output = make(model.SimCardStatusOutput, 0)
	if input == nil || len(input.SimKeys) == 0 {
		return output, nil
	}

	inputMap := make(map[string]*model.SimCardStatusInput)
	chanKeyMap, err := u.packChanKey(ctx, input.SimKeys)
	if err != nil {
		return nil, err
	}
	for chanKey, simKeys := range chanKeyMap {
		inputMap[chanKey] = &model.SimCardStatusInput{
			SimKeys: simKeys,
			ReqData: input.ReqData,
		}
	}

	for chanKey, inputNew := range inputMap {
		if chanKey == "" {
			output = appendBatchStatusFailures(output, inputNew.SimKeys, "通道未配置")
			continue
		}
		channel, ok := u.GetChan(chanKey)
		if !ok || channel.Instance == nil {
			output = appendBatchStatusFailures(output, inputNew.SimKeys, "通道未实例化")
			continue
		}
		batchChannel, ok := channel.Instance.(model.SimCardBatchQueryI)
		if !ok {
			output = appendBatchStatusFailures(output, inputNew.SimKeys, "通道不支持批量查询")
			continue
		}

		out, err := batchChannel.QuerySimCardStatusBatch(ctx, inputNew)
		if err != nil {
			output = appendBatchStatusFailures(output, inputNew.SimKeys, err.Error())
			continue
		}
		output = append(output, out...)
	}
	return output, nil
}

func (u *sUpstreamAPI) queryMonthlyBatch(ctx context.Context, input *model.SimDataUsageMonthlyInput) (output model.SimDataUsageMonthlyOutput, err error) {
	output = make(model.SimDataUsageMonthlyOutput, 0)
	if input == nil || len(input.SimKeys) == 0 {
		return output, nil
	}
	if message := validateCurrentBatchMonth(input.ReqData.QueryDate, time.Now()); message != "" {
		return appendBatchMonthlyFailures(output, input.SimKeys, message), nil
	}

	inputMap := make(map[string]*model.SimDataUsageMonthlyInput)
	chanKeyMap, err := u.packChanKey(ctx, input.SimKeys)
	if err != nil {
		return nil, err
	}
	for chanKey, simKeys := range chanKeyMap {
		inputMap[chanKey] = &model.SimDataUsageMonthlyInput{
			SimKeys: simKeys,
			ReqData: input.ReqData,
		}
	}

	for chanKey, inputNew := range inputMap {
		if chanKey == "" {
			output = appendBatchMonthlyFailures(output, inputNew.SimKeys, "通道未配置")
			continue
		}
		channel, ok := u.GetChan(chanKey)
		if !ok || channel.Instance == nil {
			output = appendBatchMonthlyFailures(output, inputNew.SimKeys, "通道未实例化")
			continue
		}
		batchChannel, ok := channel.Instance.(model.SimCardBatchQueryI)
		if !ok {
			output = appendBatchMonthlyFailures(output, inputNew.SimKeys, "通道不支持批量查询")
			continue
		}

		out, err := batchChannel.QuerySimDataUsageMonthlyBatch(ctx, inputNew)
		if err != nil {
			output = appendBatchMonthlyFailures(output, inputNew.SimKeys, err.Error())
			continue
		}
		output = append(output, out...)
	}
	return output, nil
}

func (u *sUpstreamAPI) queryDailyBatch(ctx context.Context, input *model.SimDataUsageDailyInput) (output model.SimDataUsageDailyOutput, err error) {
	output = make(model.SimDataUsageDailyOutput, 0)
	if input == nil || len(input.SimKeys) == 0 {
		return output, nil
	}
	if message := validateHistoricalDay(input.ReqData.QueryDate, time.Now()); message != "" {
		return appendBatchDailyFailures(output, input.SimKeys, message), nil
	}

	inputMap := make(map[string]*model.SimDataUsageDailyInput)
	chanKeyMap, err := u.packChanKey(ctx, input.SimKeys)
	if err != nil {
		return nil, err
	}
	for chanKey, simKeys := range chanKeyMap {
		inputMap[chanKey] = &model.SimDataUsageDailyInput{
			SimKeys: simKeys,
			ReqData: input.ReqData,
		}
	}

	for chanKey, inputNew := range inputMap {
		if chanKey == "" {
			output = appendBatchDailyFailures(output, inputNew.SimKeys, "通道未配置")
			continue
		}
		channel, ok := u.GetChan(chanKey)
		if !ok || channel.Instance == nil {
			output = appendBatchDailyFailures(output, inputNew.SimKeys, "通道未实例化")
			continue
		}
		batchChannel, ok := channel.Instance.(model.SimCardBatchQueryI)
		if !ok {
			output = appendBatchDailyFailures(output, inputNew.SimKeys, "通道不支持批量查询")
			continue
		}

		out, err := batchChannel.QuerySimDataUsageDailyBatch(ctx, inputNew)
		if err != nil {
			output = appendBatchDailyFailures(output, inputNew.SimKeys, err.Error())
			continue
		}
		output = append(output, out...)
	}
	return output, nil
}

func appendBatchStatusFailures(output model.SimCardStatusOutput, simKeys []*model.SimKey, msg string) model.SimCardStatusOutput {
	for _, simKey := range simKeys {
		output = append(output, &model.SimBaseRes[model.SimCardStatusItem]{
			SimKey:  simKey,
			Code:    consts.ApiStatusError,
			Message: msg,
		})
	}
	return output
}

func appendBatchMonthlyFailures(output model.SimDataUsageMonthlyOutput, simKeys []*model.SimKey, msg string) model.SimDataUsageMonthlyOutput {
	for _, simKey := range simKeys {
		output = append(output, &model.SimBaseRes[model.SimDataUsageMonthlyOutputItem]{
			SimKey:  simKey,
			Code:    consts.ApiStatusError,
			Message: msg,
		})
	}
	return output
}

func appendBatchDailyFailures(output model.SimDataUsageDailyOutput, simKeys []*model.SimKey, msg string) model.SimDataUsageDailyOutput {
	for _, simKey := range simKeys {
		output = append(output, &model.SimBaseRes[model.SimDataUsageDailyOutputItem]{
			SimKey:  simKey,
			Code:    consts.ApiStatusError,
			Message: msg,
		})
	}
	return output
}