const crypto = require("crypto");

// Request headers
// ---------------
const xPurchaselyRequestSignature = "f3c2a452e9ea72f41107321aeaf7999f1054148866a710c9b23f9f501785e2a4";
const xPurchaselyTimestamp = "1698322022";

// Request body
// ------------
// Please use the raw body and not an already parsed body.
// For example with Node:
//      DO: req.rawBody.toString()
//   DON'T: JSON.stringify(req.body)
const body = "{\"a_random_key\":\"a_random_value_ad\"}";

// Signature verification
// ----------------------
const webhookSharedSecret = "foobar";
const dataToSign = xPurchaselyTimestamp + body;
const computedSignature = crypto
                          .createHmac("sha256", webhookSharedSecret)
                          .update(dataToSign)
                          .digest("hex");

if (computedSignature === xPurchaselySignature) {
  // request authenticated
}

require 'openssl'

# Request headers
# ---------------
x_purchasely_signature = "f3c2a452e9ea72f41107321aeaf7999f1054148866a710c9b23f9f501785e2a4"
x_purchasely_timestamp = "1698322022"

# Request body
# ------------
# Please use the raw body and not an already parsed body.
# For example with Ruby on Rails: request.raw_post
body = "{\"a_random_key\":\"a_random_value_ad\"}"

# Signature verification
# ----------------------
webhook_shared_secret = "foobar"
data_to_sign = x_purchasely_timestamp + body
computed_signature = OpenSSL::HMAC.hexdigest('sha256', webhook_shared_secret, data_to_sign)

if (computed_signature == x_purchasely_signature) {
  # request authenticated
}

// Imports
// -------
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec

// Request headers
// ---------------
val xPurchaselySignature = "f3c2a452e9ea72f41107321aeaf7999f1054148866a710c9b23f9f501785e2a4"
val xPurchaselyTimestamp = "1698322022"

// Request body
// ------------
// Please use the raw body and not an already parsed body.
val body = "{\"a_random_key\":\"a_random_value_ad\"}"

// Signature verification
// ----------------------
val webhookSharedSecret = "foobar"
val dataToSign = xPurchaselyTimestamp + body
val hmac = Mac.getInstance("HmacSHA256")
hmac.init(SecretKeySpec(webhookSharedSecret.toByteArray(), "HmacSHA256"))
val computedSignature = hmac.doFinal(dataToSign.toByteArray()).joinToString("") { "%02x".format(it) }

if (computedSignature == xPurchaselySignature) {
    // request authenticated
}

{
  "purchasely_one_time_purchase_id":"otp_xxx", // if the purchase is a one-time-purchase,
  "purchasely_subscription_id":"subs_xxx", // if the purchase is a subscription
  "event_name": "ACTIVATE",
  "store": "APPLE_APP_STORE",
  "user_id": "<user id provided by the app to the sdk>", // if the user is logged in
  "anonymous_user_id": "<user id provided by the app to the sdk>", // if the user is not logged in
  "plan": "<plan id set in the Purchasely console>"
}

{
  "purchasely_one_time_purchase_id":"otp_xxx", // if the purchase is a one-time-purchase,
  "purchasely_subscription_id":"subs_xxx", // if the purchase is a subscription
  "event_name": "ACTIVATE",
  "store": "APPLE_APP_STORE",
  "user_id": "<user id provided by the app to the sdk>", // if the user is signed-in
  "anonymous_user_id": "<user id provided by the app to the sdk>", // if the user is signed-out
  "plan": "<plan id set in the Purchasely console>"
}

{
  "plan": "monthly",
  "store": "GOOGLE_PLAY_STORE",
  "product": "PURCHASELY_PLUS",
  "user_id": "toto",
  "event_id": "5e45109f-7fac-45f8-a7e4-464892d5d35d",
  "event_name": "ACTIVATE",
  "offer_type": "NONE",
  "api_version": 3,
  "device_type": "PHONE",
  "environment": "SANDBOX",
  "purchased_at": "2023-12-12T14:13:11.777Z",
  "purchase_type": "RENEWING_SUBSCRIPTION",
  "store_country": "FR",
  "next_renewal_at": "2023-12-12T14:23:11.777Z",
  "purchased_at_ms": 1702390391777,
  "event_created_at": "2023-12-12T14:19:26.120Z",
  "is_family_shared": false,
  "store_product_id": "com.purchasely.plus.monthly",
  "customer_currency": "EUR",
  "plan_price_in_eur": 9.99,
  "next_renewal_at_ms": 1702390991777,
  "event_created_at_ms": 1702390766120,
  "previous_offer_type": "NONE",
  "store_app_bundle_id": "com.purchasely.demo",
  "subscription_status": "AUTO_RENEWING",
  "store_transaction_id": "GPA.3355-5688-7970-28037..5",
  "original_purchased_at": "2023-12-12T13:48:16.233Z",
  "original_purchased_at_ms": 1702388896233,
  "cumulated_revenues_in_eur": 69.9,
  "effective_next_renewal_at": "2023-12-12T14:23:11.777Z",
  "purchasely_subscription_id": "subs_D7GnVQbUxvY6YxoeK6nhyPDkmyCVcfe",
  "effective_next_renewal_at_ms": 1702390991777,
  "store_original_transaction_id": "GPA.3355-5688-7970-28037",
  "plan_price_in_customer_currency": 9.99
}

{
  "plan": "monthly",
  "store": "GOOGLE_PLAY_STORE",
  "product": "PURCHASELY_PLUS",
  "user_id": "toto",
  "event_id": "3ab7e67a-6c88-44fe-8804-39897d601136",
  "event_name": "DEACTIVATE",
  "offer_type": "NONE",
  "api_version": 3,
  "device_type": "PHONE",
  "environment": "SANDBOX",
  "purchased_at": "2023-12-12T14:18:11.777Z",
  "purchase_type": "RENEWING_SUBSCRIPTION",
  "store_country": "FR",
  "next_renewal_at": "2023-12-12T14:23:11.777Z",
  "purchased_at_ms": 1702390691777,
  "event_created_at": "2023-12-12T14:24:09.412Z",
  "is_family_shared": false,
  "store_product_id": "com.purchasely.plus.monthly",
  "customer_currency": "EUR",
  "plan_price_in_eur": 9.99,
  "next_renewal_at_ms": 1702390991777,
  "event_created_at_ms": 1702391049412,
  "previous_offer_type": "NONE",
  "store_app_bundle_id": "com.purchasely.demo",
  "subscription_status": "UNPAID",
  "store_transaction_id": "GPA.3355-5688-7970-28037..5",
  "original_purchased_at": "2023-12-12T13:48:16.233Z",
  "original_purchased_at_ms": 1702388896233,
  "cumulated_revenues_in_eur": 69.9,
  "effective_next_renewal_at": "2023-12-12T14:23:11.777Z",
  "purchasely_subscription_id": "subs_D7GnVQbUxvY6YxoeK6nhyPDkmyCVcfe",
  "effective_next_renewal_at_ms": 1702390991777,
  "store_original_transaction_id": "GPA.3355-5688-7970-28037",
  "plan_price_in_customer_currency": 9.99
}

# This example uses Sinatra and ActiveRecord as ORM

#                                    CONTROLLER                                #
# ============================================================================ #
# Uses Sinatra

post '/webhook' do
  request.body.rewind
  payload = JSON.parse(request.body.read)

  entitlement = find_or_initialize_entitlement(payload)
  entitlement.attributes = {
    effective_next_renewal_at: ms_to_time(payload["effective_next_renewal_at_ms"]),
    status: payload["status"],
    store: payload["store"], # will never change
    type: payload["type"], # will never change
    last_payload: payload,
  }
  entitlement.save!

  # Acknowledges the processing of the event by answering a 200
  status 200
end


#                                      MODEL                                   #
# ============================================================================ #
# Uses ActiveRecord

# Entitlement
#
# For each purchase, it will keep track of:
#   - the purchase type
#   - the user owning it
#   - the plan bought
#   - the status of the sub (in short: active/not active)
#
# ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️
# ⚠️ Be sure to add a UNIQ CONSTRAINT on (purchasely_id, plan, anonymous_user_id, user_id) ⚠️
# ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️ ⚠️
class Entitlement < ActiveRecord::Base
  attr_accessor(
    :id,
    # filled in when the purchase is associated to a not logged in user
    :anonymous_user_id,
    # filled in when the purchase is associated to a logged in user
    :user_id,
    # RENEWING_SUBSCRIPTION | NON_RENEWING_SUBSCRIPTION |
    # CONSUMABLE | NON_CONSUMABLE
    :type, 
    # subs_xxx | otp_yyy
    :purchasely_id, 
    # Purchasely identifier of your plan, as defined in the Purchasely console
    # under the "id" input
    :plan, 
    # backup of the last payload sent
    :last_payload, 
    # At this date the user will loose their entitlement (it is equal to the max
    # between the next_renewal_at, grace_period_expires_at and defer_end_at)
    :effective_next_renewal_at,
    # AUTO_RENEWING | AUTO_RENEWING_CANCELED | IN_GRACE_PERIOD | ON_HOLD | PAUSED |
    # REVOKED | DEACTIVATED | UNPAID
    :status, 
    # APPLE_APP_STORE | GOOGLE_PLAY_STORE | STRIPE | HUAWEI_APP_GALLERY |
    # AMAZON_APP_STORE
    :store,
    :created_at,
    :updated_at
  )

  ACTIVE_STATUSES = %w[
    AUTO_RENEWING
    AUTO_RENEWING_CANCELED
    IN_GRACE_PERIOD
  ]
end


#                                     HELPERS                                  #
# ============================================================================ #

def find_or_initialize_entitlement(payload)
  Entitlement
    .find_or_initialize_by(
      payload.slice("anonymous_user_id", "plan", "purchasely_id", "user_id")
    ).last
end

def ms_to_time(time_in_ms)
  return nil unless time_in_ms

  Time.at(time_in_ms / 1000)
end

const express = require('express');
const app = express();
const bodyParser = require('body-parser');
const Entitlement = require('./models/entitlement');

app.use(bodyParser.json());


// Controller
// ============================================================================
// Uses Express

app.post('/webhook', async (req, res) => {
  const payload = req.body;

  const entitlement = await findOrInitializeEntitlement(payload);
  entitlement.effective_next_renewal_at = msToTime(payload.effective_next_renewal_at_ms);
  entitlement.status = payload.status;
  entitlement.store = payload.store; // will never change
  entitlement.type = payload.type; // will never change
  entitlement.last_payload = payload;

  await entitlement.save();

  // Acknowledges the processing of the event by answering a 200
  res.status(200).send();
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});


// Model
// ============================================================================
// Uses Mongoose

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const EntitlementSchema = new Schema({
  anonymous_user_id: { type: String, index: true },
  user_id: { type: String, index: true },
  type: { type: String, required: true },
  purchasely_id: { type: String, required: true },
  plan: { type: String, required: true },
  last_payload: { type: Object, required: true },
  effective_next_renewal_at: { type: Date },
  status: { type: String, required: true },
  store: { type: String, required: true },
  created_at: { type: Date, default: Date.now },
  updated_at: { type: Date, default: Date.now }
}, {
  timestamps: true
});

EntitlementSchema.index({ anonymous_user_id: 1, plan: 1, purchasely_id: 1, user_id: 1 }, { unique: true });

const Entitlement = mongoose.model('Entitlement', EntitlementSchema);
module.exports = Entitlement;


// Helpers
// ============================================================================

async function findOrInitializeEntitlement(payload) {
  let entitlement = await Entitlement.findOne({
    anonymous_user_id: payload.anonymous_user_id,
    plan: payload.plan,
    purchasely_id: payload.purchasely_id,
    user_id: payload.user_id
  });

  if (!entitlement) {
    entitlement = new Entitlement({
      anonymous_user_id: payload.anonymous_user_id,
      plan: payload.plan,
      purchasely_id: payload.purchasely_id,
      user_id: payload.user_id
    });
  }

  return entitlement;
}

function msToTime(timeInMs) {
  if (!timeInMs) return null;
  return new Date(timeInMs);
}

module.exports = { findOrInitializeEntitlement, msToTime };

CREATE TABLE entitlements (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    type STRING NOT NULL,
    purchasely_id STRING NOT NULL,
    anonymous_user_id STRING,
    user_id STRING,
    plan STRING NOT NULL,
    status STRING NOT NULL,
    store STRING NOT NULL,
    effective_next_renewal_at DATETIME NOT NULL,
    last_payload JSONB NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    CONSTRAINT unique_user UNIQUE (purchasely_id, user_id, anonymous_user_id)
);

Purchasely.anonymousUserId

Purchasely.anonymousUserId

Purchasely.getAnonymousUserId();

Purchasely.anonymousUserId;

Purchasely.getAnonymousUserId((anonymousId) => {
	console.log("Purchasely anonymous Id: " + anonymousId);
});

private PurchaselyRuntime.Purchasely _purchasely;

_purchasely.GetAnonymousUserId();

#                                    CONTROLLER                                #
# ============================================================================ #
# Uses Sinatra

# API endpoint to fetch user entitlements
get '/entitlements' do
  anonymous_user_id = params['anonymous_user_id'].presence
  user_id = params['user_id'].presence
  if anonymous_user_id.nil? && user_id.nil?
    status 400
    return json({error: 'user_id or anonymous_user_id is required'})
  end

  entitlements =
    Entitlement
      .where(anonymous_user_id:, user_id:) # filter on the current user
      .where(status: Entitlement::ACTIVE_STATUSES) # only retrieve the active statuses
      .to_a
  status 200
  json entitlements.map { |e| {plan: e.plan} }
end


#                                SIMPLIFIED MODEL                              #
# ============================================================================ #
# Uses ActiveRecord

class Entitlement < ActiveRecord::Base
  attr_accessor(
    # AUTO_RENEWING | AUTO_RENEWING_CANCELED | IN_GRACE_PERIOD | ON_HOLD | PAUSED |
    # REVOKED | DEACTIVATED | UNPAID
    :status, 
  )
  
  ACTIVE_STATUSES = %w[
    AUTO_RENEWING
    AUTO_RENEWING_CANCELED
    IN_GRACE_PERIOD
  ]
end

// Controller
// ============================================================================
// Uses Express

const express = require('express');
const app = express();
const Entitlement = require('./models/entitlement');

app.get('/entitlements', async (req, res) => {
  const { anonymous_user_id, user_id } = req.query;

  if (!anonymous_user_id && !user_id) {
    return res.status(400).json({ error: 'user_id or anonymous_user_id is required' });
  }

  try {
    const entitlements = await Entitlement.find({
      $or: [
        { anonymous_user_id: anonymous_user_id || null },
        { user_id: user_id || null }
      ],
      status: { $in: Entitlement.ACTIVE_STATUSES }
    }).exec();

    res.status(200).json(entitlements.map(e => ({ plan: e.plan })));
  } catch (err) {
    res.status(500).json({ error: 'An error occurred while fetching entitlements' });
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});


// Model
// ============================================================================
// Uses Mongoose

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const EntitlementSchema = new Schema({
  anonymous_user_id: { type: String, index: true },
  user_id: { type: String, index: true },
  type: { type: String, required: true },
  purchasely_id: { type: String, required: true },
  plan: { type: String, required: true },
  last_payload: { type: Object, required: true },
  effective_next_renewal_at: { type: Date },
  status: { type: String, required: true },
  store: { type: String, required: true },
  created_at: { type: Date, default: Date.now },
  updated_at: { type: Date, default: Date.now }
}, {
  timestamps: true
});

EntitlementSchema.index({ anonymous_user_id: 1, plan: 1, purchasely_id: 1, user_id: 1 }, { unique: true });

EntitlementSchema.statics.ACTIVE_STATUSES = [
  'AUTO_RENEWING',
  'AUTO_RENEWING_CANCELED',
  'IN_GRACE_PERIOD'
];

const Entitlement = mongoose.model('Entitlement', EntitlementSchema);
module.exports = Entitlement;