# frozen_string_literal: true

require "async"
require "async/http/endpoint"
require "async/websocket/client"

module Fortnox
  class AsyncClient
    LOCK_KEY = "fortnox"
    TOPICS_URL = "wss://ws.fortnox.se/topics-v1"
    TOPICS = [
      { topic: "articles" },
      { topic: "warehouse-stockbalance" },
    ].freeze

    def self.start
      lock = Lock.create(key: LOCK_KEY)
      if lock.persisted?
        Async do |task|
          new(task, lock).start
        ensure
          task&.stop
        end
      end
    ensure
      lock&.unlock!
    end

    def initialize(task, lock, logger: Rails.logger)
      @task = task
      @lock = lock
      @logger = logger
    end

    def start
      endpoint = Async::HTTP::Endpoint.parse(TOPICS_URL)

      Async::WebSocket::Client.connect(endpoint) do |connection|
        add_tenants(connection)
        add_topics(connection)
        subscribe(connection)

        while (message = connection.read)
          Event.record(message)
        end
      end
    end

    private

    attr_reader :task, :logger

    def add_tenants(connection) # rubocop:disable Metrics/MethodLength
      logger.info("Adding tenants")

      logger.debug connection.write(
        Protocol::WebSocket::JSONMessage.generate({
          command: "add-tenants-v1",
          clientSecret: "mysecret",
          accessTokens: Tenant.pluck(:token),
        })
      )
    end

    def add_topics(connection)
      logger.info("Adding topics")

      connection.write(
        Protocol::WebSocket::JSONMessage.generate({
          command: "add-topics-v1",
          topics: TOPICS,
        })
      )
    end

    def subscribe(connection)
      logger.info("Subscribing")

      connection.write(
        Protocol::WebSocket::JSONMessage.generate({ command: "subscribe-v1" })
      )
      connection.flush
    end
  end
end

# frozen_string_literal: true

require "iodine"

module Fortnox
  class IodineClient
    LOCK_KEY = "fortnox"

    def on_open(connection)
      @lock = Lock.create(key: LOCK_KEY)
      if lock.persisted?
        add_tenants(connection)
        add_topics(connection)
        subscribe(connection)
      end
    end

    def on_message(connection, message)
      Rails.logger.info "Received: #{message}"
      Event.record(message)
    end

    def on_close(_connection)
      # in this example, we stop iodine once the client is closed
      Rails.logger.info "* Client closed."
      @lock&.destroy!
      Iodine.stop
    end

    def add_tenants(connection)
      Rails.logger.info("Adding tenants")

      connection.write({
        command: "add-tenants-v1",
        clientSecret: "mysecret",
        accessTokens: Tenant.pluck(:token)
      }.to_json)
    end

    def add_topics(connection)
      Rails.logger.info("Adding topics subscriptions")

      connection.write({ command: "add-topics-v1", topics: TOPICS }.to_json)
    end

    def subscribe(connection)
      Rails.logger.info("Subscribing to websocket")

      connection.write({ command: "subscribe-v1" }.to_json)
    end
  end
end

# Iodine.threads = 1
# Iodine.workers = 1
# Iodine.connect url: Fortnox::TOPICS_URL, handler: Fortnox::IodineClient.new, ping: 40
# Iodine.start