require 'openssl'
require 'oauth2'

module Core
  class TokensController < ApplicationController
    def exchange
      validate_params(token_exchange_params)

      case token_exchange_params[:provider]
      when 'facebook'
        fb_graph = Utils::FacebookGraph.new(token_exchange_params[:provider])
        graph_user = build_omniauth_hash('facebook', fb_graph.user)
        begin
          user = Core::User.from_hash(graph_user)
        rescue ActiveRecord::RecordInvalid
          raise Errors::TokenExchangeError,
                'A user already exists with a different authentication method.'
        end

        token = find_or_create_access_token(user)
        token_response = Doorkeeper::OAuth::TokenResponse.new(token)

        headers.merge! token_response.headers
        render json: token_response.body, status: token_response.status
      else
        fail Errors::InvalidParameterError,
             'Provider not supported for Token Exchange.'
      end
    end

    protected

    def token_exchange_params
      params.permit(:provider, :token)
    end

    def validate_params(params)
      %w(provider token).each do |key|
        unless params.key? key
          fail Errors::InvalidParameterError, "Missing parameter: #{key}"
        end
      end
    end

    def build_omniauth_hash(provider, response)
      {
        provider: provider,
        id: response['id'],
        info: { name: response['name'], email: response['email'] }
      }
    end

    def find_or_create_access_token(user)
      server = Doorkeeper.configuration
      client = nil

      Doorkeeper::AccessToken.find_or_create_for(
        client,
        user.id,
        'public write',
        Doorkeeper::OAuth::Authorization::Token.access_token_expires_in(server,
                                                                        client),
        server.refresh_token_enabled?)
    end
  end
end