package common

import (
	"context"
	"strings"

	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/batchimport"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/contexts"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/rabbitmq"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/xgorm/handler"

	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
)

type AuthorizedRow interface {
	GetIccid() string
	SetAuthorized(bool)
}

type SubmitOptions struct {
	Remark string
}

type BatchExecuteMessage struct {
	BatchNo   string `json:"batchNo"`
	BatchType int    `json:"batchType"`
}

type SubmitResult struct {
	BatchNo          string
	BatchType        int
	BatchAsyncStatus int
	Total            int
}

func PrepareAuthorizedRows[T AuthorizedRow](
	ctx context.Context,
	rows []batchimport.Row,
	rowFactory func(batchimport.Row) (T, error),
	typeErrorMsg string,
) error {
	cardRows := make([]T, 0, len(rows))
	iccids := make([]string, 0, len(rows))
	for _, item := range rows {
		row, err := rowFactory(item)
		if err != nil {
			return gerror.New(typeErrorMsg)
		}
		cardRows = append(cardRows, row)
		if id := row.GetIccid(); id != "" {
			iccids = append(iccids, id)
		}
	}
	if len(iccids) == 0 {
		return nil
	}

	var visible []struct {
		Iccid string `orm:"iccid"`
	}
	columns := dao.TSimCardInfo.Columns()
	err := handler.Model(dao.TSimCardInfo.Ctx(ctx), &handler.Option{FilterTenant: true, FilterAuth: true}).
		Fields(columns.Iccid, columns.TenantId, columns.DeptId, columns.CreatedDept, columns.CreatedBy).
		WhereIn(columns.Iccid, iccids).
		Scan(&visible)
	if err != nil {
		return gerror.Wrap(err, "计算SIM卡数据权限失败")
	}

	authorized := make(map[string]struct{}, len(visible))
	for _, card := range visible {
		authorized[strings.TrimSpace(card.Iccid)] = struct{}{}
	}
	for _, row := range cardRows {
		_, ok := authorized[row.GetIccid()]
		row.SetAuthorized(ok)
	}
	return nil
}

func PublishBatchMessage(ctx context.Context, result *batchimport.Result, queueName, logPrefix string) {
	_ = PublishBatchMessageStrict(ctx, result, queueName, logPrefix)
}

func PublishBatchMessageStrict(ctx context.Context, result *batchimport.Result, queueName, logPrefix string) error {
	if result == nil || strings.TrimSpace(result.BatchNo) == "" {
		return nil
	}
	if err := rabbitmq.Publish(ctx, queueName, BatchExecuteMessage{
		BatchNo:   result.BatchNo,
		BatchType: result.BatchType,
	}); err != nil {
		g.Log().Errorf(ctx, "%s batch async publish failed, batchNo=%s, batchType=%d, tenantId=%s, error=%+v",
			logPrefix, result.BatchNo, result.BatchType, contexts.GetTenantId(ctx), err)
		return gerror.Wrap(err, "publish batch async message")
	}
	g.Log().Infof(ctx, "%s batch async published, queue=%s, batchNo=%s, batchType=%d, tenantId=%s",
		logPrefix, queueName, result.BatchNo, result.BatchType, contexts.GetTenantId(ctx))
	return nil
}

func CurrentOperator(ctx context.Context) batchimport.OperatorContext {
	return batchimport.OperatorContext{
		TenantId: contexts.GetTenantId(ctx),
		DeptId:   contexts.GetDeptId(ctx),
		UserId:   contexts.GetUserId(ctx),
	}
}

func PendingSubmitResult(result *batchimport.Result, status int) *SubmitResult {
	res := &SubmitResult{BatchAsyncStatus: status}
	if result == nil {
		return res
	}
	res.BatchNo = result.BatchNo
	res.BatchType = result.BatchType
	res.Total = result.TotalRows
	return res
}