Setting an id as a default foreign key in rails

I am having challenges assigning a current user a role in a team the user is creating. I want to assign the user that creates the team the role of the captain which could be changed later.

I'm currently using the create_asociation method that comes with has_one relationship, as this instantiates the values of the associated model, which i want to be instantiated with the current user but get the error Can't mass assign protected attribute: captain. Captain is a self join model with user as i will like to use captain.teammates and team.captain. Below are the models involved.

User and Captain Model

class User < ActiveRecord::Base
 has_one :profile

 has_many :teammates, :class_name => "User", :foreign_key => "captain_id"
 belongs_to :captain, :class_name => "User"

 belongs_to :team

 # before_create :build_profile
 after_create :build_default_profile

 accepts_nested_attributes_for :profile
 attr_accessible :email, :password, :password_confirmation, :profile_attributes, :captain_id

 def build_default_profile
  Profile.create(user_id: self.id)
 end

 has_secure_password

 before_save { email.downcase! }
 before_save :create_remember_token

 VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
 validates :email, presence: true, format: { with: VALID_EMAIL_REGEX }, 
                uniqueness: { case_sensitive: false }
 validates :password, presence: true, length: { minimum: 6 }
 validates :password_confirmation, presence: true

 private

   def create_remember_token
    self.remember_token = SecureRandom.urlsafe_base64
   end
 end

Team Model

class Team < ActiveRecord::Base
 has_many :profiles, through: :users
 has_one :captain, :class_name => "User", foreign_key: :captain_id
 has_one :result, as: :result_table

 attr_accessible :teamname, :color, :result_attributes, :captain_attributes

 after_create :build_result_table
 after_create :build_default_captain
 accepts_nested_attributes_for :profiles
 accepts_nested_attributes_for :captain
 accepts_nested_attributes_for :result

 def build_result_table
  Result.create(result_table_id: self.id, result_table_type: self.class.name)
 end

 def build_default_captain
  # Team.captain = User 
  #  Captain.create(team_id: self.id, captain_id: user.id)
 end
end

User Controller

class UsersController < ApplicationController
 before_filter :signed_in_user, only: [:index, :edit, :update, :destroy]
 before_filter :correct_user,   only: [:edit, :update]
 before_filter :admin_user,     only: :destroy

 def new
  @user = User.new
 end

 def create
  @user = User.new(params[:user])
  if @user.save!
   sign_in @user
   flash[:success] = "Welcome to the JHDC Mini Olympics Web Application; Thanks for singing Up"
   redirect_to user_profile_path(@user, @profile)
  else
   flash[:error_messages]
   render 'new'
  end
 end

 def show
  @user = User.find(params[:id])
 end

 def index
  @users = User.paginate(page: params[:page])
 end

 def edit
  @user = User.find(params[:id])
 end

 def update
  @user = User.find(params[:id])
  if @user.update_attributes(params[:user])
   flash[:success] = "Profile Updated"
   redirect_to user_profile_path(@user, @profile)
  else
   render 'edit'
  end
 end

 def destroy
  User.find(params[:id]).destroy
  flash[:success] = "User deleted."
  redirect_to users_url
 end

 private

  def signed_in_user
   unless signed_in?
   store_location
   redirect_to signin_url, notice: "Please sign in."
  end

  def correct_user
   @user = User.find(params[:id])
   redirect_to(root_path) unless current_user?(@user)
  end

  def admin_user
   redirect_to(root_path) unless current_user.admin?
  end

  def user_params
   params.require(:user).permit(:email, :password, :password_confirmation)
  end
 end
end

Team Controller

class TeamsController < ApplicationController

 def new
  @team = Team.new
 end 

 def create
  @team = Team.new(params[:team])
  @captain = @team.create_captain(captain: current_user)
  if current_user.admin?
   if @team.save!
    flash[:success] = "Team created."
    redirect_to @team
   else
    flash[:error_messages]
    render 'new'
   end
  else
   flash[:error] = "Sorry, you don't have the authority to create a Team"
   redirect_to current_user
  end
 end

 def index
  @teams = Team.paginate(page: params[:page])
 end

 def show
  @team = Team.find(params[:id])
 end

 def edit
  if current_user.admin?
   @team = Team.find(params[:id])
  else
   flash[:error] = "Sorry you dont have the authourity to edit a Team"
   redirect_to current_user
  end
 end

 def update
  @team = Team.find(params[:id])
  if @team.update_attributes(params[:team])
   flash[:success] = "Team Updated"
   redirect_to @team
  else
   render 'edit'
  end
 end

 def destroy
  Team.find(params[:id]).destroy
  flash[:success] = "Team is deleted."
  redirect_to teams_url
 end


 private

   def team_params
    params.require(:team).permit(:teamname, :color)
   end
 end

The admin is currently a way i'm using to restrict the user that can create a team but i plan to use gems like declarative authorization to create role based authorization. Thanks