# frozen_string_literal: true

require_relative "shared_context_for_backup_restore"

RSpec.describe BackupRestore::SystemInterface do
  subject(:system_interface) { BackupRestore::SystemInterface.new(logger) }

  include_context "with shared stuff"

  describe "readonly mode" do
    after { Discourse::READONLY_KEYS.each { |key| Discourse.redis.del(key) } }

    describe "#enable_readonly_mode" do
      it "enables readonly mode" do
        Discourse.expects(:enable_readonly_mode).once
        system_interface.enable_readonly_mode
      end

      it "does not enable readonly mode when it is already in readonly mode" do
        Discourse.enable_readonly_mode
        Discourse.expects(:enable_readonly_mode).never
        system_interface.enable_readonly_mode
      end
    end

    describe "#disable_readonly_mode" do
      it "disables readonly mode" do
        Discourse.expects(:disable_readonly_mode).once
        system_interface.disable_readonly_mode
      end

      it "does not disable readonly mode when readonly mode was explicitly enabled" do
        Discourse.enable_readonly_mode
        Discourse.expects(:disable_readonly_mode).never
        system_interface.disable_readonly_mode
      end
    end
  end

  describe "#mark_restore_as_running" do
    it "calls mark_restore_as_running" do
      BackupRestore.expects(:mark_as_running!).once
      system_interface.mark_restore_as_running
    end
  end

  describe "#mark_restore_as_not_running" do
    it "calls mark_restore_as_not_running" do
      BackupRestore.expects(:mark_as_not_running!).once
      system_interface.mark_restore_as_not_running
    end
  end

  describe "#listen_for_shutdown_signal" do
    before { BackupRestore.mark_as_running! }

    after do
      BackupRestore.clear_shutdown_signal!
      BackupRestore.mark_as_not_running!
    end

    it "exits the process when shutdown signal is set" do
      expect do
        thread = system_interface.listen_for_shutdown_signal
        BackupRestore.set_shutdown_signal!
        thread.join
      end.to raise_error(SystemExit)
    end

    it "clears an existing shutdown signal before it starts to listen" do
      BackupRestore.set_shutdown_signal!
      expect(BackupRestore.should_shutdown?).to eq(true)

      thread = system_interface.listen_for_shutdown_signal
      expect(BackupRestore.should_shutdown?).to eq(false)
      Thread.kill(thread)
    end
  end

  describe "#pause_sidekiq" do
    after { Sidekiq.unpause! }

    it "calls pause!" do
      expect(Sidekiq.paused?).to eq(false)
      system_interface.pause_sidekiq("my reason")
      expect(Sidekiq.paused?).to eq(true)
      expect(Discourse.redis.get(SidekiqPauser::PAUSED_KEY)).to eq("my reason")
    end
  end

  describe "#unpause_sidekiq" do
    it "calls unpause!" do
      Sidekiq.pause!
      expect(Sidekiq.paused?).to eq(true)

      system_interface.unpause_sidekiq
      expect(Sidekiq.paused?).to eq(false)
    end
  end

  describe "#wait_for_sidekiq" do
    it "waits 6 seconds even when there are no running Sidekiq jobs" do
      system_interface.expects(:sleep).with(6).once
      system_interface.wait_for_sidekiq
    end

    context "with Sidekiq workers" do
      after { flush_sidekiq_redis_namespace }

      def flush_sidekiq_redis_namespace
        Sidekiq.redis { |redis| redis.scan_each { |key| redis.del(key) } }
      end

      def create_workers(site_id: nil, all_sites: false)
        payload =
          Sidekiq::Testing.fake! do
            data = { post_id: 1 }

            if all_sites
              data[:all_sites] = true
            else
              data[:current_site_id] = site_id || RailsMultisite::ConnectionManagement.current_db
            end

            Jobs.enqueue(:process_post, data)
            Jobs::ProcessPost.jobs.last
          end

        Sidekiq.redis do |conn|
          hostname = "localhost"
          pid = 7890
          key = "#{hostname}:#{pid}"
          process = { pid: pid, hostname: hostname }

          conn.sadd?("processes", key)
          conn.hmset(key, "info", Sidekiq.dump_json(process))

          data =
            Sidekiq.dump_json(
              queue: "default",
              run_at: Time.now.to_i,
              payload: Sidekiq.dump_json(payload),
            )
          conn.hmset("#{key}:work", "444", data)
        end
      end

      it "waits up to 60 seconds for jobs running for the current site to finish" do
        system_interface.expects(:sleep).with(6).times(10)
        create_workers
        expect { system_interface.wait_for_sidekiq }.to raise_error(
          BackupRestore::RunningSidekiqJobsError,
        )
      end

      it "waits up to 60 seconds for jobs running on all sites to finish" do
        system_interface.expects(:sleep).with(6).times(10)
        create_workers(all_sites: true)
        expect { system_interface.wait_for_sidekiq }.to raise_error(
          BackupRestore::RunningSidekiqJobsError,
        )
      end

      it "ignores jobs of other sites" do
        system_interface.expects(:sleep).with(6).once
        create_workers(site_id: "another_site")

        system_interface.wait_for_sidekiq
      end
    end
  end

  describe "#flush_redis" do
    context "with Sidekiq" do
      after { Sidekiq.unpause! }

      it "doesn't unpause Sidekiq" do
        Sidekiq.pause!
        system_interface.flush_redis

        expect(Sidekiq.paused?).to eq(true)
      end
    end
  end
end