# typed: strict
# frozen_string_literal: true

module ShopifyAPI
  module Auth
    class Session
      extend T::Sig

      sig { returns(String) }
      attr_reader :id

      sig { returns(T.nilable(String)) }
      attr_accessor :state, :access_token

      sig { returns(String) }
      attr_accessor :shop

      sig { returns(AuthScopes) }
      attr_accessor :scope

      sig { returns(T.nilable(AuthScopes)) }
      attr_accessor :associated_user_scope

      sig { returns(T.nilable(Time)) }
      attr_accessor :expires

      sig { returns(T.nilable(AssociatedUser)) }
      attr_accessor :associated_user

      sig { returns(T.nilable(String)) }
      attr_accessor :shopify_session_id

      sig { returns(T::Boolean) }
      def online?
        @is_online
      end

      sig do
        params(
          shop: String,
          id: T.nilable(String),
          state: T.nilable(String),
          access_token: T.nilable(String),
          scope: T.any(T::Array[String], String),
          associated_user_scope: T.nilable(T.any(T::Array[String], String)),
          expires: T.nilable(Time),
          is_online: T.nilable(T::Boolean),
          associated_user: T.nilable(AssociatedUser),
          shopify_session_id: T.nilable(String)
        ).void
      end
      def initialize(shop:, id: nil, state: nil, access_token: "", scope: [], associated_user_scope: nil, expires: nil,
        is_online: nil, associated_user: nil, shopify_session_id: nil)
        @id = T.let(id || SecureRandom.uuid, String)
        @shop = shop
        @state = state
        @access_token = access_token
        @scope = T.let(AuthScopes.new(scope), AuthScopes)
        @associated_user_scope = T.let(
          associated_user_scope.nil? ? nil : AuthScopes.new(associated_user_scope), T.nilable(AuthScopes)
        )
        @expires = expires
        @associated_user = associated_user
        @is_online = T.let(is_online || !associated_user.nil?, T::Boolean)
        @shopify_session_id = shopify_session_id
      end

      class << self
        extend T::Sig

        sig do
          params(shop: String, access_token: String,
            blk: T.proc.params(arg0: Session).returns(T.untyped)).returns(T.untyped)
        end
        def temp(shop:, access_token:, &blk)
          original_session = Context.active_session
          temp_session = Session.new(shop: shop, access_token: access_token)

          begin
            Context.activate_session(temp_session)
            yield temp_session
          ensure
            Context.activate_session(original_session)
          end
        end
      end

      sig { returns(String) }
      def serialize
        Oj.dump(self)
      end

      sig { params(str: String).returns(Session) }
      def self.deserialize(str)
        Oj.load(str)
      end

      alias_method :eql?, :==
      sig { params(other: T.nilable(Session)).returns(T::Boolean) }
      def ==(other)
        if other
          T.must(
            id == other.id &&
            shop == other.shop &&
            state == other.state &&
            scope == other.scope &&
            associated_user_scope == other.associated_user_scope &&
            (!(expires.nil? ^ other.expires.nil?) && (expires.nil? || expires.to_i == other.expires.to_i)) &&
            online? == other.online? &&
            associated_user == other.associated_user &&
            shopify_session_id == other.shopify_session_id
          )
        else
          false
        end
      end
    end
  end
end