-- NOTA: Si tu controlador concede beneficios persistentes (moneda, objetos), usa
-- DataStoreService:UpdateAsync() en el TransferRequestId para evitar
-- la doble concesión cuando el mismo recibo se entrega a múltiples servidores.

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

-- Manejar recibos de remitentes (el jugador que envió Robux)
MarketplaceService:BindReceiptHandler(
	Enum.ReceiptType.RobuxTransferSender,
	function(receiptInfo)
		local player = Players:GetPlayerByUserId(receiptInfo.PlayerId)
		if not player then
			-- El jugador no está en este servidor; difiere para que el recibo sea
			-- redelicado al servidor en el que están actualmente
			return Enum.ReceiptDecision.NotProcessedYet
		end

		print(
			`{player.Name} envió {receiptInfo.CurrencySpent} Robux`
				.. ` (TransferRequestId: {receiptInfo.TransferRequestId})`
		)

		-- Concede cualquier reconocimiento del lado del remitente o actualiza la interfaz aquí

		return Enum.ReceiptDecision.Processed
	end
)

-- Manejar recibos de receptores (el jugador que recibió Robux)
MarketplaceService:BindReceiptHandler(
	Enum.ReceiptType.RobuxTransferReceiver,
	function(receiptInfo)
		local player = Players:GetPlayerByUserId(receiptInfo.PlayerId)
		if not player then
			return Enum.ReceiptDecision.NotProcessedYet
		end

		print(
			`{player.Name} recibió {receiptInfo.CurrencySpent} Robux`
				.. ` (TransferRequestId: {receiptInfo.TransferRequestId})`
		)

		-- Concede cualquier beneficio del lado del receptor o actualiza la interfaz aquí

		return Enum.ReceiptDecision.Processed
	end
)

local MarketplaceService = game:GetService("MarketplaceService")

local developerProducts = MarketplaceService:GetDeveloperProductsAsync():GetCurrentPage()

for _, developerProduct in pairs(developerProducts) do
	for field, value in pairs(developerProduct) do
		print(field .. ": " .. value)
	end
	print(" ")
end

local MarketplaceService = game:GetService("MarketplaceService")

local ASSET_ID = 125378389

local asset = MarketplaceService:GetProductInfoAsync(ASSET_ID)
print(asset.Name .. " :: " .. asset.Description)

local MarketplaceService = game:GetService("MarketplaceService")

local PASS_ID = 12345678
local textLabel = script.Parent

local DiscountTypeDisplay = {
	RobloxPlusSubscription = "Descuento de Roblox Plus",
}

local productInfo = MarketplaceService:GetProductInfoAsync(PASS_ID, Enum.InfoType.GamePass)
print(string.format("Precio Original: %d", productInfo.UserBasePriceInRobux))

for _, discount in ipairs(productInfo.PriceDiscountDetails) do
	local displayName = DiscountTypeDisplay[discount.Type] or "Otro Descuento"
	print(string.format("%s (%d%%): -%d", displayName, discount.Percent, discount.AmountInRobux))
end

print(string.format("Usted Paga: %d", productInfo.PriceInRobux))

local MarketplaceService = game:GetService("MarketplaceService")
local info = MarketplaceService:GetProductInfoAsync(105589844216517, Enum.InfoType.Asset)

if info.TimedOptions then
	for _, option in info.TimedOptions do
		local days = option.Duration / 86400
		print(string.format("%d días - %d Robux", days, option.Price))
	end
end

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
    local success, details = pcall(function()
        return MarketplaceService:GetRobloxSubscriptionDetailsAsync(player)
    end)

    if success and details.IsSubscribed then
        -- 1. Verificar la lealtad (por ejemplo, suscrito por > 60 días)
        local threeMonths = 60 * 24 * 60 * 60
        if details.StartTime and (os.time() - details.StartTime.UnixTimestamp) > threeMonths then
            print("¡Otorgando el skin de 'Veterano de Suscripción de 3 Meses'!")
        end

        -- 2. Verificar la atribución
        if details.IsOriginExperience then
            print("Atribución confirmada: El usuario se suscribió a través de esta experiencia.")
        else
            print("El usuario se suscribió en otro lugar (Sitio web u otra experiencia).")
        end
    end
end)

-- Obtener el MarketplaceService
local MarketplaceService = game:GetService("MarketplaceService")

-- Definir una función para recuperar los niveles de precio para una lista de usuarios
local function getPriceLevels(userIds)
    local success, result = pcall(function()
        return MarketplaceService:GetUsersPriceLevelsAsync(userIds)
    end)

    if success then
        -- Mapear cada PriceLevelInfo a una tabla de búsqueda de UserId -> PriceLevel
        local lookup = {}
        for _, info in ipairs(result) do
            lookup[info.UserId] = info.PriceLevel
        end 
        return lookup
    else
        warn("Error al obtener niveles de precio:", result)
        return nil
    end
end

-- Ejemplo usando IDs de marcador de posición
local user1Id = 123456789
local user2Id = 987654321

-- Llamar a la función y almacenar el resultado
local priceLevels = getPriceLevels({user1Id, user2Id})
-- Si es exitoso, imprimir el nivel de cada usuario
if priceLevels then
    print("Nivel de precio para el Usuario 1:", priceLevels[user1Id])
    print("Nivel de precio para el Usuario 2:", priceLevels[user2Id])
else
    print("Error al recuperar los niveles de precio.")
end

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local SUBSCRIPTION_ID = "EXP-0"

local function checkSubscriptionHistory(player: Player)
	local subscriptionHistory = {}

	local success, err = pcall(function()
		subscriptionHistory = MarketplaceService:GetUserSubscriptionPaymentHistoryAsync(player, SUBSCRIPTION_ID)
	end)

	if not success then
		warn(`Error while checking subscription history: {err}`)
		return
	end

	if next(subscriptionHistory) then
		-- El usuario tiene algún historial de suscripción dentro de los últimos 12 meses.
		-- Imprime los detalles de cada entrada de pago del historial de suscripción.
		print(`El jugador {player.Name} se ha suscrito a {SUBSCRIPTION_ID} antes:`)

		for entryNum, paymentEntry in subscriptionHistory do
			local paymentStatus = tostring(paymentEntry.PaymentStatus)
			local cycleStartTime = paymentEntry.CycleStartTime:FormatLocalTime("LLL", "es-es")
			local cycleEndTime = paymentEntry.CycleEndTime:FormatLocalTime("LLL", "es-es")
			print(`{entryNum}: {paymentStatus} ({cycleStartTime} - {cycleEndTime})`)
		end
	else
		print(`El jugador {player.Name} nunca se ha suscrito a {SUBSCRIPTION_ID} antes.`)
	end
end

-- Llama a checkSubscriptionHistory para cualquier jugador que ya esté en el juego
for _, player in ipairs(Players:GetPlayers()) do
	checkSubscriptionHistory(player)
end

-- Llama a checkSubscriptionHistory para todos los futuros jugadores
Players.PlayerAdded:Connect(checkSubscriptionHistory)

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local subscriptionID = "EXP-00000"

local function checkSubStatus(player)
	local subStatus = {}
	local success, message = pcall(function()
		-- devuelve IsRenewing e IsSubscribed
		subStatus = MarketplaceService:GetUserSubscriptionStatusAsync(player, subscriptionID)
	end)

	if not success then
		warn("Error al comprobar si el jugador tiene suscripción: " .. tostring(message))
		return
	end

	if subStatus["IsSubscribed"] then
		print(player.Name .. " está suscrito con " .. subscriptionID)
		-- Dar permisos al jugador asociados con la suscripción
	end
end

Players.PlayerAdded:Connect(checkSubStatus)

local Players = game:GetService("Players")
local MarketplaceService = game:GetService("MarketplaceService")

-- El ítem que estamos verificando: https://www.roblox.com/catalog/30331986/Midnight-Shades
local ASSET_ID = 30331986
local ASSET_NAME = "Midnight Shades"

local function onPlayerAdded(player)
	local success, doesPlayerOwnAsset =
		pcall(MarketplaceService.PlayerOwnsAssetAsync, MarketplaceService, player, ASSET_ID)
	if not success then
		local errorMessage = doesPlayerOwnAsset
		warn(`Error al verificar si {player.Name} posee {ASSET_NAME}: {errorMessage}`)
		return
	end

	if doesPlayerOwnAsset then
		print(`{player.Name} posee {ASSET_NAME}`)
	else
		print(`{player.Name} no posee {ASSET_NAME}`)
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)

local Players = game:GetService("Players")
local MarketplaceService = game:GetService("MarketplaceService")

-- El paquete que estamos verificando: https://www.roblox.com/bundles/589/Junkbot
local BUNDLE_ID = 589
local BUNDLE_NAME = "Junkbot"

Players.PlayerAdded:Connect(function(player)
	local success, doesPlayerOwnBundle = pcall(function()
		return MarketplaceService:PlayerOwnsBundleAsync(player, BUNDLE_ID)
	end)

	if success == false then
		print("La llamada a PlayerOwnsBundleAsync falló: ", doesPlayerOwnBundle)
		return
	end

	if doesPlayerOwnBundle then
		print(player.Name .. " posee " .. BUNDLE_NAME)
	else
		print(player.Name .. " no posee " .. BUNDLE_NAME)
	end
end)

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local promptBulkPurchaseEvent = ReplicatedStorage:WaitForChild("PromptBulkPurchaseEvent")

local part = Instance.new("Part")
part.Parent = workspace

local clickDetector = Instance.new("ClickDetector")
clickDetector.Parent = part

clickDetector.MouseClick:Connect(function()
	promptBulkPurchaseEvent:FireServer({
		{ Type = Enum.MarketplaceProductType.AvatarAsset, Id = "16630147" },
		{ Type = Enum.MarketplaceProductType.AvatarBundle, Id = "182" },
	})
end)

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local MarketplaceService = game:GetService("MarketplaceService")

local promptBulkPurchaseEvent = Instance.new("RemoteEvent")
promptBulkPurchaseEvent.Name = "PromptBulkPurchaseEvent"
promptBulkPurchaseEvent.Parent = ReplicatedStorage

--Escuchar el RemoteEvent para que se dispare desde un Cliente y luego activar el aviso de compra masiva
promptBulkPurchaseEvent.OnServerEvent:Connect(function(player, items)
	MarketplaceService:PromptBulkPurchase(player, items, {})
end)

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local ASSET_ID = 105589844216517

Players.PlayerAdded:Connect(function(player)
	local info = MarketplaceService:GetProductInfoAsync(ASSET_ID, Enum.InfoType.Asset)

	if info.TimedOptions and #info.TimedOptions > 0 then
		-- Encontrar la opción de duración más corta
		local shortest = info.TimedOptions[1]
		for _, option in info.TimedOptions do
			if option.Duration < shortest.Duration then
				shortest = option
			end
		end

		local items = {
			{
				Type = Enum.MarketplaceProductType.AvatarAsset,
				Id = tostring(ASSET_ID),
				PurchaseOptions = {
					{ Type = Enum.PurchaseOption.TimedOption, Value = shortest.Duration },
				},
			}
		}
		MarketplaceService:PromptBulkPurchase(player, items, {})
	end
end)

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local player = Players.LocalPlayer

local productId = 0000000 -- Cambia esto a tu ID de producto de desarrollador

-- Función para solicitar la compra del producto de desarrollador
local function promptPurchase()
	MarketplaceService:PromptProductPurchase(player, productId)
end

promptPurchase()

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local promptPurchaseEvent = ReplicatedStorage:WaitForChild("PromptPurchaseEvent")

local part = Instance.new("Part")
part.Parent = workspace

local clickDetector = Instance.new("ClickDetector")
clickDetector.Parent = part

clickDetector.MouseClick:Connect(function()
	promptPurchaseEvent:FireServer(16630147)
end)

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local MarketplaceService = game:GetService("MarketplaceService")

local promptPurchaseEvent = Instance.new("RemoteEvent")
promptPurchaseEvent.Name = "PromptPurchaseEvent"
promptPurchaseEvent.Parent = ReplicatedStorage

-- Escucha el RemoteEvent para activarse desde un Cliente y luego desencadena el aviso de compra
promptPurchaseEvent.OnServerEvent:Connect(function(player, id)
	MarketplaceService:PromptPurchase(player, id)
end)

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local teleporter = script.Parent
local showModal = true

local EXCLUSIVE_AREA_POSITION = Vector3.new(1200, 200, 60)

-- Conceder la recompensa y teletransportar al jugador suscriptor al área exclusiva
local function grantRewardAndTeleport(player)
	player:RequestStreamAroundAsync(EXCLUSIVE_AREA_POSITION)

	local character = player.Character
	if character and character.Parent then
		local currentPivot = character:GetPivot()
		character:PivotTo(currentPivot * CFrame.new(EXCLUSIVE_AREA_POSITION))
	end
end

-- Detectar partes del personaje tocando el teletransportador
teleporter.Touched:Connect(function(otherPart)
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
	if not player then
		return
	end

	if not player:GetAttribute("CharacterPartsTouching") then
		player:SetAttribute("CharacterPartsTouching", 0)
	end
	player:SetAttribute("CharacterPartsTouching", player:GetAttribute("CharacterPartsTouching") + 1)

	if player.HasRobloxSubscription then
		-- El jugador ya tiene Roblox Plus; conceder recompensa de inmediato
		grantRewardAndTeleport(player)
	else
		-- Solicitar suscripción de Roblox Plus, con un retraso para una vez cada pocos segundos
		if not showModal then
			return
		end
		showModal = false
		task.delay(5, function()
			showModal = true
		end)
		MarketplaceService:PromptRobloxSubscriptionPurchase(player)
	end
end)

-- Detectar partes del personaje saliendo del teletransportador
teleporter.TouchEnded:Connect(function(otherPart)
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
	if player and player:GetAttribute("CharacterPartsTouching") then
		player:SetAttribute("CharacterPartsTouching", player:GetAttribute("CharacterPartsTouching") - 1)
	end
end)

-- Conceder recompensa cuando el servidor confirma un cambio de suscripción
-- Conectar el cambio de HasRobloxSubscription para cada jugador
Players.PlayerAdded:Connect(function(player)
	player:GetPropertyChangedSignal("HasRobloxSubscription"):Connect(function()
		if player.HasRobloxSubscription
			and player:GetAttribute("CharacterPartsTouching")
			and player:GetAttribute("CharacterPartsTouching") > 0
		then
			grantRewardAndTeleport(player)
		end
	end)
end)

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

-- Ejemplo: transferir Robux cuando un jugador activa un RemoteEvent
local transferEvent = game.ReplicatedStorage:WaitForChild("RequestTransfer")

transferEvent.OnServerEvent:Connect(function(sender, receiverUserId, amount)
	-- Validar entradas
	if not sender or not sender:IsA("Player") then
		return
	end

	if typeof(receiverUserId) ~= "number" or receiverUserId <= 0 then
		warn("receiverUserId inválido")
		return
	end

	if typeof(amount) ~= "number" or amount <= 0 then
		warn("monto inválido")
		return
	end

	local success, result = pcall(function()
		return MarketplaceService:PromptRobuxTransferAsync(sender, receiverUserId, amount)
	end)

	if success then
		print(`Transferencia iniciada con TransferRequestId: {result}`)
	else
		warn(`Transferencia fallida: {result}`)
	end
end)

-- Obtén el MarketplaceService
  local MarketplaceService = game:GetService("MarketplaceService")

-- Crea el array de productos que quieres clasificar
local productIdentifiers = {
    {InfoType = Enum.InfoType.GamePass, Id = 123},
    {InfoType = Enum.InfoType.Product, Id = 456},
    {InfoType = Enum.InfoType.Product, Id = 789}
}

-- Llama en una llamada protegida para manejar errores de manera elegante
local success, rankedProducts = pcall(function()
    return MarketplaceService:RankProductsAsync(productIdentifiers)
end)

if not success then
    error("No se pudo clasificar los productos")
end

-- Carga los elementos devueltos en la tienda.
for i, rankedItem in ipairs(rankedProducts) do
    local productIdentifier = rankedItem.ProductIdentifier
    local productInfo = rankedItem.ProductInfo
    -- ...
    -- Lógica para agregar productos a la tienda
end

-- Obtener el MarketplaceService
local MarketplaceService = game:GetService("MarketplaceService")

-- Crear un array de tipos de productos a incluir. En este caso tanto pases de juego como productos de desarrollador
local productTypes = {Enum.InfoType.GamePass, Enum.InfoType.Product}

-- Llamar en una llamada protegida para manejar errores de manera adecuada
local success, topRankedItems = pcall(function()
    return MarketplaceService:RecommendTopProductsAsync(productTypes)
end)

if not success then
    error("No se pudo clasificar los productos")
end

-- Cargar los elementos devueltos en la tienda. Asegúrate de filtrar cualquier elemento no elegible de topRankedItems, como productos de desarrollador que el usuario ya no puede comprar
for i, rankedItem in ipairs(topRankedItems) do
    local productIdentifier = rankedItem.ProductIdentifier
    local productInfo = rankedItem.ProductInfo
    -- ...
    -- Lógica para agregar productos en la tienda
end

local MarketplaceService = game:GetService("MarketplaceService")

local function gamepassPurchaseFinished(...)
	-- Imprimir todos los detalles del aviso, por ejemplo:
	-- PromptGamePassPurchaseFinished PlayerName 123456 false
	print("PromptGamePassPurchaseFinished", ...)
end

MarketplaceService.PromptGamePassPurchaseFinished:Connect(gamepassPurchaseFinished)