package audit

import (
	"strconv"

	"github.com/break/junhong_cmp_fiber/internal/model"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
)

// PackageSeriesResource 构造套餐系列审计资源。
func PackageSeriesResource(series *model.PackageSeries, relation, role string, beforeData, afterData map[string]any) ResourceInput {
	id := strconv.FormatUint(uint64(series.ID), 10)
	var resourceID *string
	if series.ID > 0 {
		resourceID = &id
	}
	return ResourceInput{
		Type: constants.AuditResourcePackageSeries, ID: resourceID, Key: series.SeriesCode, DisplayName: series.SeriesName,
		Relation: relation, Role: role, IdentitySnapshot: map[string]any{
			"id": series.ID, "series_code": series.SeriesCode, "series_name": series.SeriesName,
			"status": series.Status, "enable_one_time_commission": series.EnableOneTimeCommission,
		},
		BeforeData: beforeData, AfterData: afterData,
	}
}

// PackageResource 构造套餐商品审计资源。
func PackageResource(pkg *model.Package, relation, role string, beforeData, afterData map[string]any) ResourceInput {
	id := strconv.FormatUint(uint64(pkg.ID), 10)
	var resourceID *string
	if pkg.ID > 0 {
		resourceID = &id
	}
	return ResourceInput{
		Type: constants.AuditResourcePackage, ID: resourceID, Key: pkg.PackageCode, DisplayName: pkg.PackageName,
		Relation: relation, Role: role, IdentitySnapshot: map[string]any{
			"id": pkg.ID, "package_code": pkg.PackageCode, "package_name": pkg.PackageName,
			"series_id": pkg.SeriesID, "package_type": pkg.PackageType, "duration_months": pkg.DurationMonths,
			"duration_days": pkg.DurationDays, "price_config_status": pkg.PriceConfigStatus,
			"is_gift": pkg.IsGift, "status": pkg.Status, "shelf_status": pkg.ShelfStatus,
		},
		BeforeData: beforeData, AfterData: afterData,
	}
}

// ShopResource 构造套餐配置关联的店铺审计资源。
func ShopResource(shop *model.Shop, relation, role string) ResourceInput {
	id := strconv.FormatUint(uint64(shop.ID), 10)
	key := shop.ShopCode
	if key == "" {
		key = id
	}
	return ResourceInput{
		Type: constants.AuditResourceShop, ID: &id, Key: key, DisplayName: shop.ShopName,
		Relation: relation, Role: role, IdentitySnapshot: map[string]any{
			"id": shop.ID, "shop_code": shop.ShopCode, "shop_name": shop.ShopName,
			"parent_id": shop.ParentID, "level": shop.Level,
		},
	}
}

// ShopSeriesAllocationResource 构造店铺系列授权审计资源。
func ShopSeriesAllocationResource(allocation *model.ShopSeriesAllocation, relation, role string, beforeData, afterData map[string]any) ResourceInput {
	id := strconv.FormatUint(uint64(allocation.ID), 10)
	var resourceID *string
	if allocation.ID > 0 {
		resourceID = &id
	}
	key := id
	if allocation.ID == 0 {
		key = "shop-series-" + strconv.FormatUint(uint64(allocation.ShopID), 10) + "-" + strconv.FormatUint(uint64(allocation.SeriesID), 10)
	}
	return ResourceInput{
		Type: constants.AuditResourceShopSeriesAllocation, ID: resourceID, Key: key, DisplayName: "系列授权 " + key,
		Relation: relation, Role: role, IdentitySnapshot: map[string]any{
			"id": allocation.ID, "shop_id": allocation.ShopID, "series_id": allocation.SeriesID,
			"allocator_shop_id": allocation.AllocatorShopID, "status": allocation.Status,
		},
		BeforeData: beforeData, AfterData: afterData,
	}
}

// ShopPackageAllocationResource 构造店铺套餐授权审计资源。
func ShopPackageAllocationResource(allocation *model.ShopPackageAllocation, relation, role string, beforeData, afterData map[string]any) ResourceInput {
	id := strconv.FormatUint(uint64(allocation.ID), 10)
	return ResourceInput{
		Type: constants.AuditResourceShopPackageAllocation, ID: &id, Key: id, DisplayName: "套餐授权 " + id,
		Relation: relation, Role: role, IdentitySnapshot: map[string]any{
			"id": allocation.ID, "shop_id": allocation.ShopID, "package_id": allocation.PackageID,
			"allocator_shop_id": allocation.AllocatorShopID, "series_allocation_id": allocation.SeriesAllocationID,
			"status": allocation.Status, "shelf_status": allocation.ShelfStatus,
			"retail_price_config_status": allocation.RetailPriceConfigStatus,
		},
		BeforeData: beforeData, AfterData: afterData,
	}
}

// ShopPackagePriceHistoryResource 构造套餐价格历史审计资源。
func ShopPackagePriceHistoryResource(history *model.ShopPackageAllocationPriceHistory) ResourceInput {
	id := strconv.FormatUint(uint64(history.ID), 10)
	return ResourceInput{
		Type: constants.AuditResourceShopPackagePriceHistory, ID: &id, Key: id, DisplayName: "价格历史 " + id,
		Relation: constants.AuditResourceRelationAffected, Role: constants.AuditResourceRolePackagePriceHistory,
		IdentitySnapshot: map[string]any{
			"id": history.ID, "allocation_id": history.AllocationID, "changed_by": history.ChangedBy,
			"effective_from": history.EffectiveFrom,
		},
		AfterData: map[string]any{
			"old_cost_price": history.OldCostPrice, "new_cost_price": history.NewCostPrice,
			"change_reason": history.ChangeReason,
		},
	}
}

// PackageConfigBatchResource 构造套餐配置批次根资源。
func PackageConfigBatchResource(batchKey, operation string, shopID, seriesID uint) ResourceInput {
	return ResourceInput{
		Type: constants.AuditResourcePackageConfigBatch, Key: batchKey, DisplayName: batchKey,
		Relation: constants.AuditResourceRelationPrimary, Role: constants.AuditResourceRolePackageConfigBatch,
		IdentitySnapshot: map[string]any{
			"batch_key": batchKey, "operation": operation, "shop_id": shopID, "series_id": seriesID,
		},
	}
}

// PackageUsageResource 构造套餐权益生命周期审计资源。
func PackageUsageResource(usage *model.PackageUsage, relation, role string, beforeData, afterData map[string]any) ResourceInput {
	id := strconv.FormatUint(uint64(usage.ID), 10)
	return ResourceInput{
		Type: constants.AuditResourcePackageUsage, ID: &id, Key: id, DisplayName: usage.PackageName,
		Relation: relation, Role: role, IdentitySnapshot: map[string]any{
			"id": usage.ID, "order_id": usage.OrderID, "order_no": usage.OrderNo,
			"refund_id": usage.RefundID, "refund_no": usage.RefundNo,
			"package_id": usage.PackageID, "package_name": usage.PackageName, "usage_type": usage.UsageType,
			"iot_card_id": usage.IotCardID, "device_id": usage.DeviceID,
			"data_limit_mb": usage.DataLimitMB, "data_usage_mb": usage.DataUsageMB,
			"activated_at": usage.ActivatedAt, "expires_at": usage.ExpiresAt, "status": usage.Status,
			"pending_realname_activation": usage.PendingRealnameActivation,
			"last_reset_at":               usage.LastResetAt, "next_reset_at": usage.NextResetAt, "generation": usage.Generation,
		},
		BeforeData: beforeData, AfterData: afterData,
	}
}

// OrderResource 构造订单审计资源。
func OrderResource(order *model.Order, relation, role string) ResourceInput {
	id := strconv.FormatUint(uint64(order.ID), 10)
	var resourceID *string
	if order.ID > 0 {
		resourceID = &id
	}
	key := order.OrderNo
	if key == "" {
		key = id
	}
	return ResourceInput{
		Type: constants.AuditResourceOrder, ID: resourceID, Key: key, DisplayName: key,
		Relation: relation, Role: role, IdentitySnapshot: map[string]any{
			"id": order.ID, "order_no": order.OrderNo, "order_type": order.OrderType,
			"buyer_type": order.BuyerType, "buyer_id": order.BuyerID,
			"iot_card_id": order.IotCardID, "device_id": order.DeviceID,
			"asset_identifier": order.AssetIdentifier, "total_amount": order.TotalAmount,
			"actual_paid_amount": order.ActualPaidAmount, "payment_method": order.PaymentMethod,
			"payment_status": order.PaymentStatus, "purchase_role": order.PurchaseRole,
			"source": order.Source, "operator_account_id": order.OperatorAccountID,
			"operator_account_type": order.OperatorAccountType, "operator_account_name": order.OperatorAccountName,
			"seller_shop_id": order.SellerShopID, "expires_at": order.ExpiresAt,
		},
	}
}

// PaymentResource 构造支付记录审计资源。
func PaymentResource(payment *model.Payment, relation, role string, beforeData, afterData map[string]any) ResourceInput {
	id := strconv.FormatUint(uint64(payment.ID), 10)
	var resourceID *string
	if payment.ID > 0 {
		resourceID = &id
	}
	key := payment.PaymentNo
	if key == "" {
		key = id
	}
	return ResourceInput{
		Type: constants.AuditResourcePayment, ID: resourceID, Key: key, DisplayName: key,
		Relation: relation, Role: role, IdentitySnapshot: map[string]any{
			"id": payment.ID, "payment_no": payment.PaymentNo, "order_id": payment.OrderID,
			"order_type": payment.OrderType, "payment_method": payment.PaymentMethod,
			"amount": payment.Amount, "status": payment.Status,
			"third_party_trade_no": payment.ThirdPartyTradeNo, "payment_config_id": payment.PaymentConfigID,
		},
		BeforeData: beforeData, AfterData: afterData,
	}
}

// RefundResource 构造退款单审计资源。
func RefundResource(refund *model.RefundRequest, relation, role string) ResourceInput {
	id := strconv.FormatUint(uint64(refund.ID), 10)
	var resourceID *string
	if refund.ID > 0 {
		resourceID = &id
	}
	key := refund.RefundNo
	if key == "" {
		key = id
	}
	return ResourceInput{
		Type: constants.AuditResourceRefund, ID: resourceID, Key: key, DisplayName: key,
		Relation: relation, Role: role, IdentitySnapshot: map[string]any{
			"id": refund.ID, "refund_no": refund.RefundNo, "order_id": refund.OrderID,
			"order_no": refund.OrderNo, "order_type": refund.OrderType,
			"package_usage_id": refund.PackageUsageID, "asset_identifier": refund.AssetIdentifier,
			"shop_id": refund.ShopID, "requested_refund_amount": refund.RequestedRefundAmount,
			"actual_received_amount": refund.ActualReceivedAmount, "refund_reason": refund.RefundReason,
			"approved_refund_amount": refund.ApprovedRefundAmount, "approval_instance_id": refund.ApprovalInstanceID,
			"status": refund.Status, "commission_deducted": refund.CommissionDeducted, "asset_reset": refund.AssetReset,
		},
	}
}