-- Check if player owns a pass
local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local PASS_ID = 123456789

local function hasPass(player)
    local success, hasPass = pcall(function()
        return MarketplaceService:UserOwnsGamePassAsync(player.UserId, PASS_ID)
    end)
    return success and hasPass
end

-- Prompt purchase
MarketplaceService:PromptGamePassPurchase(player, PASS_ID)

-- Handle purchase completion
MarketplaceService.PromptGamePassPurchaseFinished:Connect(function(player, passId, purchased)
    if purchased and passId == PASS_ID then
        -- Grant benefits
    end
end)

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

local PRODUCTS = {
    [123456] = {name = "100 Coins", coins = 100},
    [123457] = {name = "500 Coins", coins = 500},
    [123458] = {name = "Revive", type = "revive"},
}

-- IMPORTANT: Must save purchase data - Roblox doesn't track this
MarketplaceService.ProcessReceipt = function(receiptInfo)
    local player = Players:GetPlayerByUserId(receiptInfo.PlayerId)
    if not player then return Enum.ProductPurchaseDecision.NotProcessedYet end

    local product = PRODUCTS[receiptInfo.ProductId]
    if not product then return Enum.ProductPurchaseDecision.NotProcessedYet end

    -- Grant the product
    local success = pcall(function()
        if product.coins then
            -- Add coins to player data
            addCoins(player, product.coins)
        elseif product.type == "revive" then
            revivePlayer(player)
        end
    end)

    if success then
        return Enum.ProductPurchaseDecision.PurchaseGranted
    end
    return Enum.ProductPurchaseDecision.NotProcessedYet
end

-- Prompt purchase
MarketplaceService:PromptProductPurchase(player, productId)

local MarketplaceService = game:GetService("MarketplaceService")

local SUBSCRIPTION_ID = "EXP-123456"

-- Check active subscription
local function hasSubscription(player)
    local success, result = pcall(function()
        return MarketplaceService:GetUserSubscriptionStatusAsync(player, SUBSCRIPTION_ID)
    end)
    return success and result and result.IsSubscribed
end

-- Prompt subscription
MarketplaceService:PromptSubscriptionPurchase(player, SUBSCRIPTION_ID)

-- Detect private server
local privateServerId = game.PrivateServerId
local privateServerOwnerId = game.PrivateServerOwnerId

local isPrivateServer = privateServerId ~= "" and privateServerId ~= nil

-- Dropper system
local function createDropper(tycoon, dropperData)
    local dropper = Instance.new("Part")
    -- Dropper creates "bricks" that fall onto conveyor

    local function drop()
        local brick = Instance.new("Part")
        brick.Size = Vector3.new(1, 1, 1)
        brick.Position = dropper.Position - Vector3.new(0, 2, 0)
        brick.Parent = workspace.Drops

        -- Brick value (can be upgraded)
        brick:SetAttribute("Value", dropperData.baseValue * tycoon.multiplier)
    end

    -- Auto-drop or click-to-drop
    if dropperData.auto then
        task.spawn(function()
            while true do
                drop()
                task.wait(dropperData.interval)
            end
        end)
    end
end

-- Rebirth system (prestige)
local function rebirth(player)
    local data = getPlayerData(player)
    if data.money >= getRebirthCost(data.rebirths) then
        data.rebirths = data.rebirths + 1
        data.multiplier = 1 + (data.rebirths * 0.5)  -- 50% boost per rebirth
        data.money = 0
        -- Reset tycoon but keep multiplier
        resetTycoon(player)
    end
end

-- Click/tap to collect
local function collectResource(player, amount)
    local data = getPlayerData(player)
    local collected = math.min(amount * data.multiplier, data.maxCapacity - data.current)
    data.current = data.current + collected
end

-- Sell resources for currency
local function sell(player)
    local data = getPlayerData(player)
    local earnings = data.current * data.sellMultiplier
    data.coins = data.coins + earnings
    data.current = 0
end

-- Pet system with multipliers
local function equipPet(player, petId)
    local pet = getPetData(petId)
    local data = getPlayerData(player)
    data.multiplier = data.baseMultiplier * pet.boostMultiplier
end

-- Area unlock system
local function canAccessArea(player, area)
    local data = getPlayerData(player)
    return data.rebirths >= area.requiredRebirths
        or data.coins >= area.coinCost
        or hasPass(player, area.passId)
end

-- Checkpoint system
local function setupCheckpoint(checkpoint, stageNumber)
    checkpoint.Touched:Connect(function(hit)
        local player = Players:GetPlayerFromCharacter(hit.Parent)
        if player then
            local data = getPlayerData(player)
            if stageNumber > data.currentStage then
                data.currentStage = stageNumber
                -- Respawn point
                player.RespawnLocation = checkpoint
            end
        end
    end)
end

-- Skip stage (monetization)
local function skipStage(player)
    local data = getPlayerData(player)
    data.currentStage = data.currentStage + 1
    respawnAtStage(player, data.currentStage)
end

-- Kill brick
local killBrick = Instance.new("Part")
killBrick.Touched:Connect(function(hit)
    local humanoid = hit.Parent:FindFirstChild("Humanoid")
    if humanoid then
        humanoid.Health = 0
    end
end)

-- Daily login rewards
local function checkDailyReward(player)
    local data = getPlayerData(player)
    local today = os.date("%Y-%m-%d")

    if data.lastLogin ~= today then
        data.loginStreak = (data.lastLoginDate == yesterday())
            and data.loginStreak + 1
            or 1
        data.lastLogin = today

        -- Grant daily reward based on streak
        local reward = DAILY_REWARDS[math.min(data.loginStreak, #DAILY_REWARDS)]
        grantReward(player, reward)
    end
end

-- Limited time events
local function isEventActive(eventId)
    local event = EVENTS[eventId]
    local now = os.time()
    return now >= event.startTime and now <= event.endTime
end

-- Trading system
local function initiateTrade(player1, player2, offer1, offer2)
    -- Verify both players have items
    -- Show trade UI to both
    -- Require confirmation from both
    -- Execute swap atomically
end

-- Limited time items create urgency
local function isItemAvailable(itemId)
    local item = ITEMS[itemId]
    if item.limitedTime then
        return os.time() <= item.endTime
    end
    return true
end

local DataStoreService = game:GetService("DataStoreService")
local purchaseStore = DataStoreService:GetDataStore("Purchases")

-- Always save after granting product
local function recordPurchase(player, receiptId, productId)
    local key = "user_" .. player.UserId
    local success, err = pcall(function()
        purchaseStore:UpdateAsync(key, function(oldData)
            oldData = oldData or {purchases = {}}
            table.insert(oldData.purchases, {
                receiptId = receiptId,
                productId = productId,
                timestamp = os.time()
            })
            return oldData
        end)
    end)
    return success
end