array = [1, 2, 3, [:a, :b, :c, [true]]]

uri = URI::UID.build(array).to_s
#=> "uid://universal-id/iweAlAECA5TUAGHUAGLUAGORwwM"

uid = URI::UID.parse(uri)
#=> #<URI::UID uid://universal-id/iweAlAECA5TUAGHUAGLUAGORwwM>

uid.decode
#=> [1, 2, 3, [:a, :b, :c, [true]]]

hash = {a: 1, b: 2, c: 3, array: [1, 2, 3, [:a, :b, :c, [true]]]}

uri = URI::UID.build(hash).to_s
#=> "uid://universal-id/CxKAhNQAYQHUAGIC1ABjA8cFAGFycmF5lAEC..."

uid = URI::UID.parse(uri)
#=> #<URI::UID uid://universal-id/CxKAhNQAYQHUAGIC1ABjA8cFAGFycmF5lAECA5TUAGHUAGLUAGORwwM>

uid.decode
#=> {:a=>1, :b=>2, :c=>3, :array=>[1, 2, 3, [:a, :b, :c, [true]]]}

ostruct = OpenStruct.new(
  name: "Wireless Keyboard",
  price: 49.99,
  category: "Electronics",
  in_stock: true
)

uri = URI::UID.build(ostruct).to_s
#=> "uid://universal-id/iyaAx0sMhNYAbmFtZbFXaXJlbGVzcyBLZXlib2FyZMcFAHByaWNly0BI_rhR64Uf1wBjYXRlZ29ye..."

uid = URI::UID.parse(uri)
#=> #<URI::UID scheme=uid, host=universal-id, payload=iyaAx0sMhNYAbmFtZbFXaXJlbGVzcyBLZXlib2FyZMcFAHByaWNly0BI_rhR64Uf1wBjYXRlZ29ye...>

uid.decode
#=> #<OpenStruct name="Wireless Keyboard", price=49.99, category="Electronics", in_stock=true>

set = Set.new([1, 2, 3, [:a, :b, :c, [true]]])

uri = URI::UID.build(set).to_s
#=> "uid://universal-id/iwiA2AuUAQIDlNQAYdQAYtQAY5HDAw"

uid = URI::UID.parse(uri)
#=> #<URI::UID uid://universal-id/iwiA2AuUAQIDlNQAYdQAYtQAY5HDAw>

URI::UID.parse(uri).decode
#=> #<Set: {1, 2, 3, [:a, :b, :c, [true]]}>

Book = Struct.new(:title, :author, :isbn, :published_year)
book = Book.new("The Great Gatsby", "F. Scott Fitzgerald", "9780743273565", 1925)

uri = URI::UID.build(book).to_s
#=> "uid://universal-id/G2YAoGTomv9N_4RV2oJRxRvZdC1wNJ0H3Ipu45kVcSrAxtg6Wjtogpi6GV1XXQAOAXoNR3BrCg9AQ..."

uid = URI::UID.parse(uri)
#=> #<URI::UID scheme=uid, host=universal-id, payload=G2YAoGTomv9N_4RV2oJRxRvZdC1wNJ0H3Ipu45kVcSrAxtg6Wjtogpi6GV1XXQAOAXoNR3BrCg9AQ...>

uid.decode
#=> #<struct Book title="The Great Gatsby", author="F. Scott Fitzgerald", isbn="9780743273565", published_year=1925>

class UserSettings
  attr_accessor :user_id, :preferences

  def initialize(user_id, preferences = {})
    @user_id = user_id
    @preferences = preferences
  end
end

UniversalID::MessagePackFactory.register(
  type: UserSettings,
  packer: ->(user_preferences, packer) do
    packer.write user_preferences.user_id
    packer.write user_preferences.preferences
  end,
  unpacker: ->(unpacker) do
    user_id = unpacker.read
    preferences = unpacker.read
    UserSettings.new user_id, preferences
  end
)

settings = UserSettings.new(1,
  theme: "dark",
  notifications: "email",
  language: "en",
  layout: "grid",
  privacy: "private"
)

uri = URI::UID.build(settings).to_s
#=> "uid://universal-id/G1QAQAT-bfcGW1QOgadJwJF06yL8gDnGgfs1Xdti20TDDvG5STPqzbYcQ6TBqVKhdZ39CdQZUwEGe..."

uid = URI::UID.parse(uri)
#=> #<URI::UID uid://universal-id/G1QAQAT-bfcGW1QOgadJwJF06yL8gDnGgfs1Xdti20TDDvG5STPqzbYcQ6TBqVKhdZ39CdQZUwEGe..."

uid.decode
=> #<UserSettings:0x0000000139157dd8 @preferences={:theme=>"dark", :notifications=>"email", :language=>"en", :layout=>"grid", :privacy=>"private"}, @user_id=1>

ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")

ActiveRecord::Schema.define do
  create_table :campaigns do |t|
    t.column :name, :string
    t.timestamps
  end
end

class Campaign < ApplicationRecord
end

# ---

campaign = Campaign.create(name: "Marketing Campaign")

uri = URI::UID.build(campaign).to_s
#=> "uid://universal-id/CwiAxw4EqENhbXBhaWdugaJpZAMD"

uid = URI::UID.parse(uri)
#=> #<URI::UID uid://universal-id/CwiAxw4EqENhbXBhaWdugaJpZAMD>

URI::UID.parse(uri).decode
##<Campaign:0x000000011cc67da8 id: 1, name: "Marketing Campaign", ...>

person = {
  full_name: "Jane Doe",
  email: "[email protected]",
  birthdate: "1980-05-15",
  phone_number: "555-6789",
  ssn: "123-45-6789",
  children: [
    {
      full_name: "Alice Doe",
      email: "[email protected]",
      birthdate: nil,
      phone_number: "555-1234",
      ssn: "987-65-4321"
    },
    {
      full_name: "Bob Doe",
      email: "[email protected]",
      birthdate: "2008-11-21",
      phone_number: nil,
      ssn: "456-12-1234"
    }
  ]
}

uid = URI::UID.build(person, include_blank: false, exclude: [:phone_number, :ssn])
uid.decode

# Note that the decoded payload is smaller due to the prepack options
# Also note that the options were applied recursively

{
  full_name: "Jane Doe",
  email: "[email protected]",
  birthdate: "1980-05-15",
  children: [
    {
      full_name: "Alice Doe",
      email: "[email protected]"
    },
    {
      full_name: "Bob Doe",
      email: "[email protected]",
      birthdate: "2008-11-21"
    }
  ]
}

UniversalID::Settings.register :unsaved, File.expand_path("app/config/unsaved.yml", __dir__)
URI::UID.build @record, UniversalID::Settings[:small_record]

ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")

ActiveRecord::Schema.define do
  create_table :campaigns do |t|
    t.column :name, :string
    t.column :description, :text
    t.column :trigger, :string
    t.timestamps
  end

  create_table :emails do |t|
    t.column :campaign_id, :integer
    t.column :subject, :string
    t.column :body, :text
    t.column :wait, :integer
    t.timestamps
  end

  create_table :attachments do |t|
    t.column :email_id, :integer
    t.column :file_name, :string
    t.column :content_type, :string
    t.column :file_size, :integer
    t.column :file_data, :binary
    t.timestamps
  end
end

class Campaign < ApplicationRecord
  has_many :emails, dependent: :destroy
end

class Email < ApplicationRecord
  belongs_to :campaign
  has_many :attachments, dependent: :destroy
end

class Attachment < ApplicationRecord
  belongs_to :email
end

campaign = Campaign.new(
  name: "Summer Sale Campaign",
  description: "A campaign for the summer sale, targeting our loyal customers.",
  trigger: "SummerStart"
)

# NOTE: Assigning campaign.emails via `=` to ensure ActiveRecord flags the association as `loaded`
campaign.emails = 3.times.map do |i|
  email = campaign.emails.build(
    subject: "Summer Sale Special Offer #{i + 1}",
    body: "Dear Customer, check out our exclusive summer sale offers! #{i + 1}",
    wait: rand(1..14)
  )

  # NOTE: Assigning email.attachments via `=` to ensure ActiveRecord flags the association as `loaded`
  email.tap do |e|
    e.attachments = 2.times.map do |j|
      data = SecureRandom.random_bytes(rand(500..1500))
      e.attachments.build(
        file_name: "summer_sale_#{i + 1}_attachment_#{j + 1}.pdf",
        content_type: "application/pdf",
        file_size: data.size,
        file_data: data
      )
    end
  end
end

# demonstrate that we have new unsaved records

#campaign
campaign.new_record? # true
campaign.changed? # true

# emails
campaign.emails.each do |email|
  email.new_record? # true
  email.changed? # true

  email.attachments.each do |attachment|
    attachment.new_record? # true
    attachment.changed? # true
  end
end

# prepack options
options = {
  include_unsaved_changes: true,
  include_descendants: true,
  descendant_depth: 2
}

# NOTE: The campaign model instance was setup earlier in the "Model Instances" section above
campaign.new_record? # true
campaign.changes
# {
#   "name"=>[nil, "Summer Sale Campaign"],
#   "description"=>[nil, "A campaign for the summer sale, targeting our loyal customers."],
#   "trigger"=>[nil, "SummerStart"]
# }

campaign.emails.each do |email|
  email.new_record? # true
  email.changes
  # {
  #   "subject"=>[nil, "Summer Sale Special Offer ..."],
  #   "body"=>[nil, "Dear Customer, check out our exclusive summer sale offers! ..."],
  #   "wait"=>[nil, ...]
  # }

  email.attachments.each do |attachment|
    attachment.new_record? # true
    attachment.changes
    # {
    #   "file_name"=>[nil, "summer_sale_..._attachment_....pdf"],
    #   "content_type"=>[nil, "application/pdf"],
    #   "file_size"=>[nil, ...],
    #   "file_data"=>[nil, "..."]
    # }
  end
end

encoded = URI::UID.build(campaign, options).to_s
restored = URI::UID.parse(encoded).decode

restored.new_record? # true
restored.changes
# {
#   "name"=>[nil, "Summer Sale Campaign"],
#   "description"=>[nil, "A campaign for the summer sale, targeting our loyal customers."],
#   "trigger"=>[nil, "SummerStart"]
# }

restored.emails.each do |email|
  email.new_record? # true
  email.changes
  # {
  #   "subject"=>[nil, "Summer Sale Special Offer ..."],
  #   "body"=>[nil, "Dear Customer, check out our exclusive summer sale offers! ..."],
  #   "wait"=>[nil, ...]
  # }

  email.attachments.each do |attachment|
    attachment.new_record? # true
    attachment.changes
    # {
    #   "file_name"=>[nil, "summer_sale_..._attachment_....pdf"],
    #   "content_type"=>[nil, "application/pdf"],
    #   "file_size"=>[nil, ...],
    #   "file_data"=>[nil, "..."]
    # }
  end
end

# NOTE: The campaign model instance was setup earlier in the "Model Instances" section above
# persist the model and its associations
campaign.save!

# make some unsaved changes to the records
campaign.name = "Changed Name #{SecureRandom.hex}"
campaign.emails.each do |email|
  email.subject = "Changed Subject #{SecureRandom.hex}"
  email.attachments.each do |attachment|
    attachment.file_name = "changed_file_name#{SecureRandom.hex}.pdf"
  end
end

campaign.persisted? # true
campaign.changes
# {"name"=>["Summer Sale Campaign", "Changed Name ..."]}

campaign.emails.each do |email|
  email.persisted? # true
  email.changes
  # {"subject"=>["Summer Sale Special Offer 1", "Changed Subject ..."]}

  email.attachments.each do |attachment|
    attachment.persisted? # true
    attachment.changes
    # {"file_name"=>["summer_sale_..._attachment_....pdf", "changed_file_name....pdf"]}
  end
end

# prepack options
options = {
  include_unsaved_changes: true,
  include_descendants: true,
  descendant_depth: 2
}

encoded = URI::UID.build(campaign, options).to_s
restored = URI::UID.parse(encoded).decode

restored.persisted? # true
restored.changes
# {"name"=>["Summer Sale Campaign", "Changed Name ..."]}

restored.emails.each do |email|
  email.persisted? # true
  email.changes
  # {"subject"=>["Summer Sale Special Offer 1", "Changed Subject ..."]}

  email.attachments.each do |attachment|
    attachment.persisted? # true
    attachment.changes
    # {"file_name"=>["summer_sale_..._attachment_....pdf", "changed_file_name....pdf"]}
  end
end

# NOTE: The campaign model instance was setup earlier in the "Model Instances" section above
# persist the model and its associations
campaign.save!

options = {
  include_keys: false,
  include_timestamps: false,
  include_unsaved_changes: true,
  include_descendants: true,
  descendant_depth: 2
}

encoded = URI::UID.build(campaign, options).to_s
copy = URI::UID.parse(encoded).decode

campaign.persisted? # false
copy.new_record? # true
copy.save!

copy == campaign # false

campaign.emails.each do |email|
  copy_email_ids = copy.emails.map(&:id)
  campaign_email_ids = campaign.emails.map(&:id)
  (copy_email_ids && campaign_email_ids).any? # false

  copy_attachment_ids = copy.emails.map(&:attachments).flatten.map(&:id)
  campaign_attachment_ids = campaign.emails.map(&:attachments).flatten.map(&:id)
  (copy_attachment_ids & campaign_attachment_ids).any? # false
end

# Assuming we have multiple campaigns already stored in the database
relation = Campaign.joins(:emails).where("emails.subject LIKE ?", "Flash Sale%")

# force load the relation
relation.load
relation.loaded? # true

encoded = URI::UID.build(relation).to_s
decoded = URI::UID.parse(encoded).decode

decoded.is_a? ActiveRecord::Relation # true
decoded.loaded? # false
decoded == relation # true
decoded.size == relation.size # true
decoded.to_a == relation.to_a # true

product = {
  name: "Wireless Bluetooth Headphones",
  price: 79.99,
  category: "Electronics"
}

uid = URI::UID.build(product)
#=> #<URI::UID scheme="uid", host="universal-id", path="/G0sAgBypU587HsjkLpEnGHiaWfPQEyiiuH6j...">

sgid = uid.to_sgid_param(for: "cart-123", expires_in: 1.hour)
#=> "eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaEpJZ0d4WjJsa09pOHZkVzVwZG1WeWMyRnNMV2xrTDFWU1NUbzZWVWxFT2pwSGJHOWlZV3hKUkZKbFkyOXlaQzlITUhO..."

URI::UID.from_sgid(sgid, for: "cart-123").decode
#=> {
#     name: "Wireless Bluetooth Headphones",
#     price: 79.99,
#     category: "Electronics"
#   }


# mismatched purpose returns nil... as expected
URI::UID.from_sgid(sgid, for: "mismatch")
#=> nil

# NOTE: The campaign model instance was setup earlier in the "Model Instances" section above
campaign.save!

#           the uid build target (campaign in this case)
#                                    |
#                                    |  encoding options (whatever was passed to URI::UID.build or {})
#                                    |        |
uid = URI::UID.build(campaign) do |record, options|
  # NOTE: this feature is compatible with other tools like kiba, amoeba, etc.
  #       that can be leveraged to generate the data to be encoded

  data = { id: record.id, demo: true }

  URI::UID.encode data, options.merge(include: %w[id demo]) # block returns the encoded payload
end

#                                              fingerprint components
#                                                     ____|______
#                     the decoded payload from above  |         |
#                                              |      |         |
decoded = URI::UID.parse(uid.to_s).decode do |data, klass, timestamp|
  # NOTE: this feature is compatible with other tools like kiba, amoeba, etc.
  #       that can be leveraged to translate the decoded data into the correct format

  record = klass.find_by(id: data[:id])
  record.instance_variable_set(:@demo, data[:demo])

  case Time.parse(timestamp)
  when 3.months.ago..Time.now
    # current data format
    # return the record as-is
    record
  when 1.year.ago..3.months.ago
    # outdated data format
    # apply an ETL process to bring the outdated data current
    # then return the modified record
    record
  end
end