// Node.js backend
const NETWORK_ID = '${NETWORK_ID}';
const BIDDER_URL = `https://das.idealo.com/${NETWORK_ID}/bid`;

// User identifiers — replace with actual values from your system
const SESSION_ID = 'your-session-id';      // session-level identifier (no GDPR consent required)
const TRACKING_ID = 'your-tracking-id';    // device-level tracking identifier (GDPR consent required)

const requestBody = {
    id: Math.random().toString(16).substring(2, 15),
    imp: [
        // Each slot is replicated ×3 (same tagid, unique ids) to increase the number of ad candidates
        // Slot 1 — product-tile-slider (first/best position)
        { id: 'imp-1-0', tagid: 'product-tile-slider', secure: 1, native: { request: '{}' }, ext: { no_redirect: true, offers_limit: 3 } },
        { id: 'imp-1-1', tagid: 'product-tile-slider', secure: 1, native: { request: '{}' }, ext: { no_redirect: true, offers_limit: 3 } },
        { id: 'imp-1-2', tagid: 'product-tile-slider', secure: 1, native: { request: '{}' }, ext: { no_redirect: true, offers_limit: 3 } },
        // Slot 2 — product-tile-slider2 (additional positions), pos required; 3 replicas
        { id: 'imp-2-0', tagid: 'product-tile-slider2', secure: 1, native: { request: '{}' }, ext: { no_redirect: true, offers_limit: 3, pos: 1 } },
        { id: 'imp-2-1', tagid: 'product-tile-slider2', secure: 1, native: { request: '{}' }, ext: { no_redirect: true, offers_limit: 3, pos: 1 } },
        { id: 'imp-2-2', tagid: 'product-tile-slider2', secure: 1, native: { request: '{}' }, ext: { no_redirect: true, offers_limit: 3, pos: 1 } },
    ],
    site: {
        id: 'DEMO_PAGE',                              // your site ID (UPPERCASE)
        page: 'https://your-shop.com/page-url',      // full URL of the page containing the slider
        ext: {
            area: 'OOP'                               // page type context — provided by Ring DAS account manager
        }
    },
    user: {
        eids: [{
            source: 'your-domain.com',
            inserter: 'your-domain.com',
            uids: [
                {
                    id: SESSION_ID,
                    atype: 500,
                    ext: { id_type: 'session', consent_required: false }
                },
                {
                    id: TRACKING_ID,
                    atype: 1,
                    ext: { id_type: 'tracking', consent_required: true }
                }
            ]
        }],
        ext: {
            npa: false,                               // false = consent given, true = no consent
            ids: {
                lu: '202408221036415499301131'        // Ring DAS internal session ID (from ea_uuid cookie)
            }
        }
    },
    ext: {
        network: NETWORK_ID,
        keyvalues: {
            main_category_id: 101,                    // main category ID of the viewed product
            IP: '202603041502158687149647',            // page view ID
            IV: '202603041502158687149647',            // page view unique ID
            TABID: 'tab-7f3e2a',                      // browser tab identifier
            ab_variant: 'variant-b',                  // optional: A/B test variant identifier
        },
        offerids: ['10', '20', '1234'],               // optional: product IDs from current page
        excluded_offer_ids: ['10', '102'],           // organic offer IDs from price table — prevents duplicate display
        categoryids: [101, 205],                      // optional: category IDs for targeting
        is_non_prebid_request: true,
        src: 's2s'                                    // indicates server-to-server request
    },
    regs: {
        gdpr: 1,
        gpp: 'YOUR_GPP_STRING',                       // optional: TCF-compliant consent string
        ext: { dsa: 1 }
    },
    tmax: 1000
};

// Send as GET request with body in data= parameter
const encodedData = encodeURIComponent(JSON.stringify(requestBody));
const response = await fetch(`${BIDDER_URL}?data=${encodedData}`);

if (response.status === 204) {
    console.log('No ad available');
    return [];
}

const bidResponse = await response.json();

// Map impression IDs to slider containers — must match the imp[] ids from the request
const SLOT_CONFIG = [
    { impIds: ['imp-1-0', 'imp-1-1', 'imp-1-2'], containerId: 'ad-slider-1' },
    { impIds: ['imp-2-0', 'imp-2-1', 'imp-2-2'], containerId: 'ad-slider-2' },
];

/**
 * Resolve one slider slot: find the first catalog match across all impression replicas.
 * @param {object} bidResponse - Full bid response from the bidder
 * @param {object} slot - Slot definition from SLOT_CONFIG
 * @returns {object|null} Resolved ad data, or null if no catalog match found
 */
async function resolveSlot(bidResponse, slot) {
    for (const seat of bidResponse.seatbid) {
        for (const bid of seat.bid) {
            // Check if this bid belongs to this slot's impression group
            if (!slot.impIds.includes(bid.impid)) continue;

            const adm = JSON.parse(bid.adm);
            const offers = adm.fields?.feed?.offers || [];
            const redirectToOffers = adm.fields?.feed?.redirectToOffers;
            const dsaInfo = bid.ext?.dsa
                ? { advertiser: bid.ext.dsa.behalf, payer: bid.ext.dsa.paid }
                : null;

            // Find the first offer available in your shop catalog
            for (const offer of offers) {
                const product = redirectToOffers
                    ? await fetchProductFromCatalog(offer.product_id, offer.offer_id)  // Sponsored Offers: needs product_id + offer_id
                    : await fetchProductFromCatalog(offer.product_id);                  // Sponsored Product: product_id only

                if (product) {
                    return {
                        matchedOffer: offer,
                        redirectToOffers,
                        shopProduct: product,
                        dsaInfo,
                        containerId: slot.containerId,
                        adm: bid.adm,   // raw adm string — passed to registerBidResponse()
                    };
                }
            }
        }
    }
    console.log(`No catalog match for slot "${slot.containerId}"`);
    return null;
}

// Resolve all slots
const resolvedSlots = [];
for (const slot of SLOT_CONFIG) {
    const result = await resolveSlot(bidResponse, slot);
    if (result) resolvedSlots.push(result);
}

<!-- Slider container — inject server-rendered HTML below -->
<div id="product-slider">

    <% resolvedSlots.forEach(adData => { %>
    <div id="<%= adData.containerId %>" class="slider-card sponsored-card">

        <% if (adData.dsaInfo) { %>
        <div class="dsa-info">
            Advertiser: <%= adData.dsaInfo.advertiser %> &middot; Paid by: <%= adData.dsaInfo.payer %>
        </div>
        <% } %>

        <span class="sponsored-badge">Sponsored</span>

        <% if (adData.redirectToOffers === false) { %>
        <!-- SPONSORED PRODUCT: tile links to product page on your shop -->
        <a href="<%= adData.shopProduct.url %>"
           target="_blank" rel="noopener nofollow sponsored"
           onclick="new Image().src='<%= adData.matchedOffer.adclick %>'; return true;">
            <img src="<%= adData.shopProduct.image %>" alt="<%= adData.shopProduct.name %>">
            <div class="product-name"><%= adData.shopProduct.name %></div>
            <div class="product-price">
                <%= new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(adData.shopProduct.price) %>
            </div>
        </a>

        <% } else { %>
        <!-- SPONSORED OFFERS: product from your catalog + CTA linking to merchant's shop -->
        <img src="<%= adData.shopProduct.image %>" alt="<%= adData.shopProduct.name %>">
        <div class="product-name"><%= adData.shopProduct.name %></div>
        <div class="product-price">
            <%= new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(adData.shopProduct.price) %>
        </div>
        <a class="cta-button"
           href="<%= adData.matchedOffer.offer_url %>"
           target="_blank" rel="noopener nofollow sponsored"
           onclick="new Image().src='<%= adData.matchedOffer.adclick %>'; return true;">
            View offer
        </a>
        <% } %>

    </div>
    <% }) %>

</div>

// Injected by the server into the page
const resolvedSlotsData = <%- JSON.stringify(resolvedSlots.map(s => ({
    adm: s.adm,
    containerId: s.containerId,
}))) %>;

// Runs in the browser after SDK loads
dlApi.cmd.push(function (dlApi) {
    resolvedSlotsData.forEach(function (slotData) {
        dlApi.registerBidResponse(slotData.adm, slotData.containerId);
    });
});

<script>
    dlApi = {
        target: "DEMO_PAGE/OOP",      // Format: SITE/AREA — use the area matching your page context
        tid: 'EA-<<NETWORK_ID>>',     // your tenant ID — provided by Ring DAS
        cmd: []
    };
</script>
<!-- SDK URL — provided by your Ring DAS account manager -->
<script src="https://<<DAS_CDN>>/<<NETWORK_ID>>/build/dlApi/minit.boot.min.js" async></script>

dlApi.cmd.push(function (dlApi) {
    dlApi.consent({ npa: 0 });  // 0 = consent given, 1 = no consent
});

dlApi.cmd.push(function (dlApi) {
    dlApi.addKeyValue('main_category_id', 101);
    dlApi.addKeyValue('IP', '202603041502158687149647');   // page view ID
    dlApi.addKeyValue('IV', '202603041502158687149647');   // page view unique ID (changes on SPA transitions)
    dlApi.addKeyValue('TABID', 'tab-7f3e2a');              // browser tab identifier
});