require "rails_helper"

RSpec.describe AcquiredMediaReleasesController, type: :controller do
  render_views

  let(:user) { create(:user) }
  let(:account) { user.primary_account } 
  let(:project) { create(:project, account: user.primary_account) }

  before do
    sign_in user
  end

  describe "#index" do
    it "responds successfully" do
      get :index, params: { project_id: project }

      expect(response).to be_successful
    end

    it "renders content" do
      release = create(:acquired_media_release, project: project, name: "My Release")
      create(:note, notable: release, content: "Some notes here")
      get :index, params: { project_id: project }

      expect(response.body).to have_content "My Release"
      expect(response.body).to have_content "0"
      expect(response.body).to have_content "Some notes here"
      expect(response.body).to have_link "Import Release"
      expect(response.body).to have_content "Manage"
    end

    context "when there are no acquired_media releases" do
      it "renders an empty message" do
        get :index, params: { project_id: project }

        expect(response.body).to have_content("Acquired Media Releases will appear here")
      end
    end

    context "when there are many records" do
      it "paginates the table" do
        create_list(:acquired_media_release, 20, project: project)

        get :index, params: { project_id: project }

        expect(response.body).to have_link("2", href: project_acquired_media_releases_path(project, page: 2))
      end
    end

    context "for xhr request" do
      it "filters the releases by a query param" do
        acquired_media_releases = [
          create(:acquired_media_release, name: "OJ Simpson Trial Audio", project: project),
          create(:acquired_media_release, name: "Shark Footage", project: project),
        ]

        get :index, params: { project_id: project, query: "Shark" }, xhr: true

        expect(response.body).not_to have_content("OJ")
        expect(response.body).to have_content("Shark")
      end
    end
  end

  describe "#new" do
    it "responds successfully" do
      get :new, params: { project_id: project }

      expect(response).to be_successful
    end
  end

  describe "#create" do
    it "responds successfully" do
      expect {
        post :create, params: { project_id: project, acquired_media_release: acquired_media_release_params }
      }.to change(AcquiredMediaRelease, :count).by(1)

      expect(response).to redirect_to [project, :acquired_media_releases]
      expect(flash.notice).not_to be_nil
    end

    it "enqueues tagging job" do
      expect {
        post :create, params: { project_id: project, acquired_media_release: acquired_media_release_params }
      }.to have_enqueued_job(SetTagsForReleasableJob).with(AcquiredMediaRelease.last)
    end

    it "adds files to release" do
      post :create, params: { project_id: project, acquired_media_release: acquired_media_release_params.merge(file_params) }

      expect(AcquiredMediaRelease.last.files.size).to eq(1)
    end

    context "when the record would be invalid" do
      before :each do
        allow_any_instance_of(AcquiredMediaRelease).to receive(:save).and_return(false)
      end

      it "re-renders the form" do
        expect {
          post :create, params: { project_id: project, acquired_media_release: { name: "" } }
        }.not_to change(AcquiredMediaRelease, :count)

        expect(response).to be_successful
        expect(response.body).to include "Import Acquired Media Release"
      end

      it "does not enqueue any jobs" do
        expect {
          post :create, params: { project_id: project, acquired_media_release: acquired_media_release_params }
        }.not_to have_enqueued_job
      end
    end
  end

  describe "#edit" do
    let(:non_native_acquired_media_release) { create(:acquired_media_release, project: project ) }
    let(:native_acquired_media_release) { create(:acquired_media_release, :native, project: project ) }

    it "responds successfully for non-native release" do
      get :edit, params: { id: non_native_acquired_media_release }

      expect(response).to be_successful
    end

    it "responds with error for native release" do
      expect{get :edit, params: { id: native_acquired_media_release }}.to raise_exception Pundit::NotAuthorizedError
    end
  end

  describe "#update" do
    let(:acquired_media_release) { create(:acquired_media_release, project: project) }

    it "responds successfully" do
      put :update, params: { id: acquired_media_release, acquired_media_release: { name: "Updated name" } }

      expect(response).to redirect_to [project, :acquired_media_releases]
      expect(flash.notice).to eq "The acquired media release has been updated"
      expect(acquired_media_release.reload.name).to eq "Updated name"
    end

    context "when the record would be invalid" do
      before :each do
        allow_any_instance_of(AcquiredMediaRelease).to receive(:update).and_return(false)
      end

      it "re-renders the form" do
        put :update, params: { id: acquired_media_release, acquired_media_release: acquired_media_release_params }

        expect(response).to render_template :edit
        expect(flash.notice).to be_nil
      end
    end
  end

  describe "#destroy" do
    let!(:acquired_media_release) { create(:acquired_media_release, project: project) }

    it "destroys the record" do
      expect {
        delete :destroy, params: { id: acquired_media_release }
      }.to change(AcquiredMediaRelease, :count).by(-1)
    end

    it "redirects to project and sets alert" do
      delete :destroy, params: { id: acquired_media_release }

      expect(response).to redirect_to [project, :acquired_media_releases]
      expect(flash.alert).to eq "The acquired media release has been deleted"
    end
  end

  private

  def acquired_media_release_params
    attributes_for(:acquired_media_release).merge(exploitable_rights_params)
  end

  def exploitable_rights_params
    {
      applicable_medium_id: ApplicableMedium.last.id,
      applicable_medium_text: "applicable_media",
      territory_id: Territory.last.id,
      territory_text: "territory",
      term_id: Term.last.id,
      term_text: "term",
      restriction_id: Restriction.last.id,
      restriction_text: "restrictions",
    }
  end

  def file_params
    path = Rails.root.join("spec", "fixtures", "files", "contract.pdf")
    contract_file = Rack::Test::UploadedFile.new(path, "application/pdf")

    { files: [contract_file] }
  end
end