require 'spec_helper'

describe Lifen::User do

  let(:valid_token_value)   { "valid_token" }

  let(:invalid_token)       { Lifen::Token.new(value: "invalid_token", expires_at: Time.now.to_i + 60) }
  let(:valid_token)         { Lifen::Token.new(value: valid_token_value, expires_at: Time.now.to_i + 60) }

  describe ':create' do
    context 'missing field' do

      let(:user) { Lifen::User.new(first_name: "Marc") }

      it 'raises an error' do
        expect{
          VCR.use_cassette "users/create/missing_fields" do
            user.create
          end
        }.to raise_error(Lifen::Error, "Error 401, Invalid app bearer, App Client, POST 'https://develop.lifen.fr/authentication/api/register/third_party' with params '{:emailAddress=>nil, :lastName=>nil, :firstName=>\"Marc\", :profilePicUrl=>nil}' and bearer 'valid_application_access******'")
      end
    end

    context 'invalid secret key' do

      let(:user) { Lifen::User.new(email: "invalid-key-email@test.tld") }

      before do
        Lifen.configure do |config|
          config.application_access_token = "invalid-secret-key"
        end
      end

      it 'raises an error' do
        expect{
          VCR.use_cassette "users/create/invalid_token" do
            user.create
          end
        }.to raise_error(Lifen::InvalidSecretTokenError, "Error 401, Invalid app bearer, App Client, POST 'https://develop.lifen.fr/authentication/api/register/third_party' with params '{:emailAddress=>\"invalid-key-email@test.tld\", :lastName=>nil, :firstName=>nil, :profilePicUrl=>nil}' and bearer 'invalid-secret-key'")
      end
    end

    context 'exisiting user' do
      let(:user) { Lifen::User.new(email: "existing-user@domain.tld", first_name: "Existing", last_name: "User") }

      it 'creates the user' do

        expect{
          VCR.use_cassette "users/create/existing_user" do
            user.create
          end
        }.to raise_error(Lifen::UserAlreadyExistingError, "Error 403, User already existing, App Client, POST 'https://develop.lifen.fr/authentication/api/register/third_party' with params '{:emailAddress=>\"existing-user@domain.tld\", :lastName=>\"User\", :firstName=>\"Existing\", :profilePicUrl=>nil}' and bearer 'valid_application_access******'")
      end
    end

    context 'valid attributes' do
      let(:user) { Lifen::User.new(email: "valid-email-spec@domain.tld", first_name: "Valid", last_name: "User") }

      it 'creates the user' do

        VCR.use_cassette "users/create/valid_attributes" do
          user.create
        end

        expect(user.uuid).to_not be_nil
      end

      describe 'thread safe' do

        class PersistedUser < Struct.new(:lifen_uuid) ; end

        let(:storage)                 { double("Storage") }

        let(:marc)                    { Lifen::User.new(email: "existing-user@domain.tld", first_name: "Existing", last_name: "User") }
        let(:antoine)                 { Lifen::User.new(email: "existing-user@domain.tld", first_name: "Existing", last_name: "Marc") }

        before do
          allow(storage).to receive(:find_by) do
            PersistedUser.new(nil)
          end
        end

        it 'queues refresh calls' do

          threads = []

          threads << Thread.new do
            VCR.use_cassette "users/create/valid_attributes" do
              marc.create(
                persisted_lifen_uuid: ->(user) {
                  # Loading data from DB
                  storage.find_by(email: user.email).lifen_uuid
                },
                save_to_db: ->(user) {
                  # saving data to DB

                  allow(storage).to receive(:find_by) do
                    PersistedUser.new(user.uuid)
                  end
                }
              )
            end
          end

          sleep 0.1 # Making sure the mocked call is received first

          threads << Thread.new do

            # No cassette, should raise an issue if HTTP call is needed
            antoine.create(
              persisted_lifen_uuid: ->(user) {
                # Loading data from DB

                storage.find_by(email: user.email).lifen_uuid
              }
            )
          end

          threads.map { |t| t.join } # waiting for all threads to finish
        end

      end



    end

  end


  describe ':token.refresh' do

    context 'invalid user uuid' do

      let(:user) { Lifen::User.new(uuid: "invalid-user-uuid") }

      it 'raises an error' do
        expect{
          VCR.use_cassette "users/token/refresh/invalid_user_uuid" do
            user.token.refresh
          end
        }.to raise_error(Lifen::Error, "Error 500, Internal server error (trace ID: unknown), App Client, POST 'https://develop.lifen.fr/oauth/admin/third_party/access_token?accountUuid=invalid-user-uuid' with params '{}' and bearer 'valid_application_access******'")
      end
    end

    context 'valid user uuid' do

      let(:user) { Lifen::User.new(uuid: "11e6be14-8267-25ee-a3bd-0242ac110002") }

      it 'raises an error' do

        previous_token_value = user.token.value

        VCR.use_cassette "users/token/refresh/valid_user_uuid" do
          user.token.refresh
        end

        expect(user.token.value).to_not be_nil
        expect(user.token.value).to_not eq previous_token_value
      end
    end

  end

  describe ':status.reload' do

    context 'invalid token' do
      let(:user) { Lifen::User.new(token: invalid_token) }

      it 'raises an error' do
        expect{
          VCR.use_cassette "users/status/reload/invalid_token" do
            user.status
          end
        }.to raise_error(Lifen::Error, "Error 401, Token is not valid, User Client, GET 'https://develop.lifen.fr/central/api/chats/status' with params '{}' and bearer 'invalid_token'")
      end
    end

    context 'valid token' do

      # let(:valid_token_value)     { "REPLACE_ME" }
      let(:user)            { Lifen::User.new(token: valid_token) }

      it 'raises an error' do
        VCR.use_cassette "users/status/reload/valid_token" do
          user.status
        end

        expect(user.unread_messages).to eq 2
      end
    end

  end

  describe ':find' do

    context 'existing uuid' do

      it 'finds the user' do
        VCR.use_cassette "users/find/existing_uuid" do
          @user = Lifen::User.find("11e6cc11-a78f-ad5d-9506-0242ac110002")
        end

        expect(@user.first_name).to eq "Etienne"
        expect(@user.last_name).to eq "Depaulis"
        expect(@user.email).to eq "etienne.depaulis@honestica.com"
      end

    end

    context 'missing uuid' do

      it 'raises an error' do
        expect{
          VCR.use_cassette "users/find/missing_uuid" do
            @user = Lifen::User.find("missing_uuid")
          end
        }.to raise_error(Lifen::Error, "Error 400, Unknown error, App Client, GET 'https://develop.lifen.fr/docbook/api/thirdParty/person/missing_uuid' with params '{}' and bearer 'valid_application_access******'")
      end

    end

  end

  describe ':save' do

    let(:user) { Lifen::User.new(uuid: "11e6cc11-a78f-ad5d-9506-0242ac110002") }

    it 'saves the user' do
      user.first_name = "Marc"

      VCR.use_cassette "users/save/existing_uuid" do
        user.save
      end

      VCR.use_cassette "users/reload/existing_uuid" do
        user.reload
      end

      expect(user.first_name).to eq "Marc"
    end

  end

  describe ':find_by_rpps' do

    it 'finds the users' do
      VCR.use_cassette "users/find_by_rpps/existing_rpps" do
        @user = Lifen::User.find_by_rpps("810004085790")
      end

      expect(@user.channels.size).to eq(3)

      address = @user.channels.last

      expect(address.value).to eq "Batiment Nord, 11 RUE CHARLES TELLIER, 75016 Paris"
    end


  end

  describe ':create_channel' do

    let(:user) { Lifen::User.new(uuid: "11e5c85e-9bc0-4c6e-9b29-deb9993a92c0") }

    it 'creates the channel' do
      VCR.use_cassette "users/create_channel/valid_attributes" do
        @channel = user.create_channel(type: "address", lines: ["Honestica", "39 rue d'Aboukir"], city: "Paris", postal_code: "75002", country: "France")
      end

      expect(@channel.value).to eq "Honestica, 39 rue d'Aboukir, 75002 Paris"
      expect(@channel.uuid).to eq "11e70577-f114-5cde-b13b-0242ac110002"
      expect(user.channels.size).to eq 1
    end
  end


end