include ActionDispatch::TestProcess # added for artifact_update http://stackoverflow.com/questions/5990835/factory-with-carrierwave-upload-field

FactoryGirl.define do
  factory :user, :class => JamRuby::User do
    sequence(:email) { |n| "person_#{n}@example.com"}   
    sequence(:first_name)  { |n| "Person" }
    sequence(:last_name)  { |n| "#{n}" }
    password "foobar"
    password_confirmation "foobar"
    email_confirmed true
    show_whats_next false #annoying for testing, usually
    musician true
    city "Apex"
    state "NC"
    country "US"
    terms_of_service true
    subscribe_email true
    last_jam_audio_latency 5

    factory :fan do
      musician false
    end

    factory :admin do
      admin true
    end

    factory :band_musician do
      after(:create) do |user|
        band = FactoryGirl.create(:band)
        user.bands << band
        # user.band_musicians << BandMusician.create(:band_id => band.id, :user_id => user.id, :admin => true)
      end
    end

    before(:create) do |user|
      user.musician_instruments << FactoryGirl.build(:musician_instrument, user: user)
    end

    factory :user_two_instruments do
      before(:create) do |user|
        user.musician_instruments << FactoryGirl.create(:musician_instrument, user: user, instrument: JamRuby::Instrument.find('drums'), proficiency_level: 2, priority:1 )
      end
    end

    factory :single_user_session do
      after(:create) do |user, evaluator|
        music_session = FactoryGirl.create(:active_music_session, :creator => user)
        connection = FactoryGirl.create(:connection, :user => user, :music_session => music_session)
      end
    end
  end

  factory :musician_instrument, :class=> JamRuby::MusicianInstrument do
    instrument { Instrument.find('electric guitar') }
    proficiency_level 1
    priority 0
  end


  factory :invited_user, :class => JamRuby::InvitedUser do
    sequence(:email) { |n| "user#{n}@someservice.com" }
    autofriend false
  end

  factory :active_music_session_no_user_history, :class => JamRuby::ActiveMusicSession do

    association :creator, factory: :user

    ignore do
      name "My Music Session"
      description "Come Music Session"
      fan_chat true
      fan_access true
      approval_required false
      musician_access true
      legal_terms true
      genre JamRuby::Genre.first
      band nil
      language 'eng'
    end


    before(:create) do |session, evaluator|
      music_session = FactoryGirl.create(:music_session, name: evaluator.name, description: evaluator.description, fan_chat: evaluator.fan_chat,
                                         fan_access: evaluator.fan_access, approval_required: evaluator.approval_required, musician_access: evaluator.musician_access,
                                         genre: evaluator.genre, creator: evaluator.creator, band: evaluator.band, language: evaluator.language)
      session.id = music_session.id
    end

    factory :active_music_session do
      after(:create) { |session|
        FactoryGirl.create(:music_session_user_history, :history => session.music_session, :user => session.creator)
      }

      factory :music_session_with_mount do
        association :mount, :factory => :icecast_mount
      end
    end
  end

  factory :music_session, :class => JamRuby::MusicSession do
    sequence(:name) { |n| "Music Session #{n}" }
    sequence(:description) { |n| "Music Session Description #{n}" }
    fan_chat true
    fan_access true
    approval_required false
    musician_access true
    legal_terms true
    language 'eng'
    legal_policy 'Standard'
    genre JamRuby::Genre.first
    association :creator, :factory => :user
    open_rsvps true
    scheduled_start Time.now
    recurring_mode 'once'
    scheduled_duration 3600
    timezone "UTC,Etc/UTC"


    factory :recurring_music_session_weekly do
      recurring_mode 'weekly'
    end

    after(:create) do |music_session|
      FactoryGirl.create(:chosen_rsvp_slot, user: music_session.creator, music_session: music_session)
    end
  end

  factory :music_session_user_history, :class => JamRuby::MusicSessionUserHistory do
    ignore do
      history nil
      user nil
    end

    music_session_id { history.id }
    user_id { user.id }
    sequence(:client_id) { |n| "Connection #{n}" }
  end


  factory :connection, :class => JamRuby::Connection do
    sequence(:client_id) { |n| "client_id#{n}"}
    ip_address "1.1.1.1"
    as_musician true
    addr {JamIsp.ip_to_num(ip_address)}
    locidispid 0
    client_type 'client'
    sequence(:channel_id) { |n| "Channel#{n}"}
  end

  factory :friendship, :class => JamRuby::Friendship do

  end

  factory :invitation, :class => JamRuby::Invitation do

  end

  factory :friend_request, :class => JamRuby::FriendRequest do

  end

  factory :band, :class => JamRuby::Band do
    sequence(:name)  { |n| "Band" }
    biography "Established 1978"
    city "Apex"
    state "NC"
    country "US"
    before(:create) { |band|
      band.genres << Genre.first
    }

    factory :band_with_follower do
      after(:create) do |band|
        u = FactoryGirl.create(:fan)
        f = FactoryGirl.create(:following, :followable_id => band.id,
                               :followable_type => "JamRuby::Band", :user_id => u.id)
        band.followers << f
      end
    end
  end

  factory :following, :class => JamRuby::Follow do

  end

  factory :join_request, :class => JamRuby::JoinRequest do
    text 'let me in to the session!'
  end
  
  factory :genre, :class => JamRuby::Genre do
    description { |n| "Genre #{n}" }
  end
  
  factory :instrument, :class => JamRuby::Instrument do
    description { |n| "Instrument #{n}" }
  end

  factory :artifact_update, :class => JamRuby::ArtifactUpdate do
    sequence(:version) { |n| "0.1.#{n}" }
    uri { fixture_file_upload("#{Rails.root.to_s}/spec/fixtures/files/jkclient.exe", "application/x-msdownload")  }
    product { "JamClient/Win32" }
    environment { "public" }
    sha1 { "blurp" }
    size { 20 }
  end

  factory :track, :class => JamRuby::Track do
    sound "mono"
    sequence(:client_track_id) { |n| "client_track_id_seq_#{n}"}

  end


  factory :recorded_track, :class => JamRuby::RecordedTrack do
    instrument JamRuby::Instrument.first
    sound 'stereo'
    sequence(:client_id) { |n| "client_id-#{n}"}
    sequence(:track_id) { |n| "track_id-#{n}"}
    sequence(:client_track_id) { |n| "client_track_id-#{n}"}
    md5 'abc'
    length 1
    fully_uploaded true
    association :user,          factory: :user
    association :recording,     factory: :recording
  end

  factory :recording, :class => JamRuby::Recording do

    association :owner,           factory: :user
    association :music_session,   factory: :active_music_session

    factory :recording_with_track do
      before(:create) { |recording|
        recording.recorded_tracks << FactoryGirl.create(:recorded_track, recording: recording, user: recording.owner)
      }
    end
  end

  factory :claimed_recording, :class => JamRuby::ClaimedRecording do
    sequence(:name) { |n| "name-#{n}" }
    sequence(:description) { |n| "description-#{n}" }
    is_public true
    association :genre,      factory: :genre
    association :user,       factory: :user

    before(:create) { |claimed_recording|
      claimed_recording.recording = FactoryGirl.create(:recording_with_track, owner: claimed_recording.user)
    }

  end

  factory :icecast_limit, :class => JamRuby::IcecastLimit do
    clients 5
    sources 1
    queue_size 102400
    client_timeout 30
    header_timeout 15
    source_timeout 10
    burst_size 65536
  end

  factory :icecast_admin_authentication, :class => JamRuby::IcecastAdminAuthentication do
    source_pass     Faker::Lorem.characters(10)
    admin_user          Faker::Lorem.characters(10)
    admin_pass      Faker::Lorem.characters(10)
    relay_user          Faker::Lorem.characters(10)
    relay_pass      Faker::Lorem.characters(10)
  end

  factory :icecast_directory, :class => JamRuby::IcecastDirectory do
    yp_url_timeout      15
    yp_url              Faker::Lorem.characters(10)
  end

  factory :icecast_master_server_relay, :class => JamRuby::IcecastMasterServerRelay do
    master_server       Faker::Lorem.characters(10)
    master_server_port  8000
    master_update_interval 120
    master_username     Faker::Lorem.characters(10)
    master_pass     Faker::Lorem.characters(10)
    relays_on_demand    1
  end

  factory :icecast_path, :class => JamRuby::IcecastPath do
    base_dir            Faker::Lorem.characters(10)
    log_dir             Faker::Lorem.characters(10)
    pid_file            Faker::Lorem.characters(10)
    web_root            Faker::Lorem.characters(10)
    admin_root          Faker::Lorem.characters(10)
  end

  factory :icecast_logging, :class => JamRuby::IcecastLogging do
    access_log          Faker::Lorem.characters(10)
    error_log           Faker::Lorem.characters(10)
    log_level           3
    log_archive         nil
    log_size            10000
  end

  factory :icecast_security, :class => JamRuby::IcecastSecurity do
    chroot              0
  end

  factory :icecast_mount, :class => JamRuby::IcecastMount do
    name                "/" + Faker::Lorem.characters(10)
    source_username     Faker::Lorem.characters(10)
    source_pass         Faker::Lorem.characters(10)
    max_listeners       100
    max_listener_duration 3600
    fallback_mount      Faker::Lorem.characters(10)
    fallback_override   1
    fallback_when_full  1
    is_public           -1
    stream_name         Faker::Lorem.characters(10)
    stream_description  Faker::Lorem.characters(10)
    stream_url          Faker::Lorem.characters(10)
    genre               Faker::Lorem.characters(10)
    hidden              0
    association         :server, factory: :icecast_server_with_overrides

    factory :icecast_mount_with_auth do
      association :authentication, :factory => :icecast_user_authentication

      factory :iceast_mount_with_template do
        association :mount_template, :factory => :icecast_mount_template

        factory :iceast_mount_with_music_session do
          association :music_session, :factory => :music_session
        end
      end
    end


  end

  factory :icecast_listen_socket, :class => JamRuby::IcecastListenSocket do
    port                8000
  end

  factory :icecast_relay, :class => JamRuby::IcecastRelay do
    port                8000
    mount               Faker::Lorem.characters(10)
    server              Faker::Lorem.characters(10)
    on_demand           1
  end

  factory :icecast_user_authentication, :class => JamRuby::IcecastUserAuthentication do
    authentication_type 'url'
    unused_username     Faker::Lorem.characters(10)
    unused_pass         Faker::Lorem.characters(10)
    mount_add           Faker::Lorem.characters(10)
    mount_remove        Faker::Lorem.characters(10)
    listener_add        Faker::Lorem.characters(10)
    listener_remove     Faker::Lorem.characters(10)
    auth_header         'icecast-auth-user: 1'
    timelimit_header    'icecast-auth-timelimit:'
  end

  factory :icecast_server, :class => JamRuby::IcecastServer do
    sequence(:hostname) { |n| "hostname-#{n}"}
    sequence(:server_id) { |n| "server-#{n}"}

    factory :icecast_server_minimal do
      association :template, :factory => :icecast_template_minimal
      association :mount_template, :factory => :icecast_mount_template

      factory :icecast_server_with_overrides do
        association :limit, :factory => :icecast_limit
        association :admin_auth, :factory => :icecast_admin_authentication
        association :path, :factory => :icecast_path
        association :logging, :factory => :icecast_logging
        association :security, :factory => :icecast_security

        before(:create) do |server|
          server.listen_sockets << FactoryGirl.build(:icecast_listen_socket)
        end
      end
    end
  end

  factory :icecast_template, :class => JamRuby::IcecastTemplate do

    sequence(:name) { |n| "name-#{n}"}
    sequence(:location) { |n| "location-#{n}"}

    factory :icecast_template_minimal do
      association :limit, :factory => :icecast_limit
      association :admin_auth, :factory => :icecast_admin_authentication
      association :path, :factory => :icecast_path
      association :logging, :factory => :icecast_logging
      association :security, :factory => :icecast_security

      before(:create) do |template|
        template.listen_sockets << FactoryGirl.build(:icecast_listen_socket)
      end
    end
  end

  factory :icecast_mount_template, :class => JamRuby::IcecastMountTemplate do
    sequence(:name) { |n| "name-#{n}"}
    source_username     Faker::Lorem.characters(10)
    source_pass         Faker::Lorem.characters(10)
    max_listeners       100
    max_listener_duration 3600
    fallback_mount      Faker::Lorem.characters(10)
    fallback_override   1
    fallback_when_full  1
    is_public           -1
    stream_name         Faker::Lorem.characters(10)
    stream_description  Faker::Lorem.characters(10)
    stream_url          Faker::Lorem.characters(10)
    genre               Faker::Lorem.characters(10)
    hidden              0
    association         :authentication, :factory => :icecast_user_authentication
  end

  factory :facebook_signup, :class => JamRuby::FacebookSignup do
    sequence(:lookup_id)      { |n| "lookup-#{n}"}
    sequence(:first_name)     { |n| "first-#{n}"}
    sequence(:last_name)      { |n| "last-#{n}"}
    gender                    'M'
    sequence(:email)          { |n| "jammin-#{n}@jamkazam.com"}
    sequence(:uid)            { |n| "uid-#{n}"}
    sequence(:token)          { |n| "token-#{n}"}
    token_expires_at          Time.now
  end

  factory :playable_play, :class => JamRuby::PlayablePlay do

  end

  factory :recording_like, :class => JamRuby::RecordingLiker do

  end

  factory :music_session_like, :class => JamRuby::MusicSessionLiker do

  end


  factory :mix, :class => JamRuby::Mix do
    started_at Time.now
    completed_at Time.now
    ogg_md5 'abc'
    ogg_length 1
    sequence(:ogg_url) { |n| "recordings/ogg/#{n}" }
    mp3_md5 'abc'
    mp3_length 1
    sequence(:mp3_url) { |n| "recordings/mp3/#{n}" }
    completed true

    before(:create) {|mix|
      user = FactoryGirl.create(:user)
      mix.recording = FactoryGirl.create(:recording_with_track, owner: user)
      mix.recording.claimed_recordings << FactoryGirl.create(:claimed_recording, user: user, recording: mix.recording)
    }
  end


  factory :event, :class => JamRuby::Event do
    sequence(:slug)           { |n| "slug-#{n}" }
    title                     'event title'
    description               'event description'
  end

  factory :event_session, :class => JamRuby::EventSession do
  end

  factory :notification, :class => JamRuby::Notification do

    factory :notification_text_message do
      description 'TEXT_MESSAGE'
      message Faker::Lorem.characters(10)
    end
  end

  factory :rsvp_slot, class: JamRuby::RsvpSlot do

    proficiency_level 'beginner'
    instrument        { Instrument.find('electric guitar') }
    association       :music_session, :factory => :music_session

    factory :chosen_rsvp_slot do
      ignore do
        user nil
      end

      after(:create) { |rsvp_slot, evaluator|
        rsvp_request = FactoryGirl.create(:rsvp_request, user: evaluator.user)
        rsvp_request_rsvp_slot = FactoryGirl.create(:rsvp_request_rsvp_slot, chosen:true, rsvp_request: rsvp_request, rsvp_slot:rsvp_slot)
      }
    end

    factory :requested_rsvp_slot do
      ignore do
        user nil
      end

      after(:create) { |rsvp_slot, evaluator|
        rsvp_request = FactoryGirl.create(:rsvp_request, user: evaluator.user)
        rsvp_request_rsvp_slot = FactoryGirl.create(:rsvp_request_rsvp_slot, chosen:nil, rsvp_request: rsvp_request, rsvp_slot:rsvp_slot)
      }
    end
  end

  factory :rsvp_request, class: JamRuby::RsvpRequest do
    canceled false
    cancel_all false
    association :user, :factory => :user

    # creates *number* slots for a new rsvp_request
    factory :rsvp_request_for_multiple_slots do
      ignore do
        music_session nil
        number 1
        chosen nil
      end

      after(:create) { |rsvp_request, evaluator |
        evaluator.number.times do |i|
          slot = FactoryGirl.create(:rsvp_slot, music_session: evaluator.music_session, instrument: Instrument.order(:id).limit(1).offset(i).first, proficiency_level: 1)
          FactoryGirl.create(:rsvp_request_rsvp_slot, chosen: evaluator.chosen, rsvp_request: rsvp_request, rsvp_slot:slot)
        end
      }
    end

    # creates a rsvp_request for the specified slots
    factory :rsvp_request_for_slots do
      ignore do
        slots nil
        chosen nil
      end

      after(:create) { |rsvp_request, evaluator |
        evaluator.slots.each do |slot|
          FactoryGirl.create(:rsvp_request_rsvp_slot, chosen:evaluator.chosen, rsvp_request: rsvp_request, rsvp_slot:slot)
        end
      }
    end
  end

  factory :rsvp_request_rsvp_slot, class: JamRuby::RsvpRequestRsvpSlot do
    chosen false
  end

  factory :diagnostic, :class => JamRuby::Diagnostic do
    type JamRuby::Diagnostic::NO_HEARTBEAT_ACK
    creator JamRuby::Diagnostic::CLIENT
    data Faker::Lorem.sentence
  end

  factory :latency_tester, :class => JamRuby::LatencyTester do
    ignore do
      connection nil
      make_connection  true
    end

    sequence(:client_id) { |n| "LatencyTesterClientId-#{n}" }

    after(:create) do |latency_tester, evaluator|
      latency_tester.connection = evaluator.connection if evaluator.connection
      latency_tester.connection = FactoryGirl.create(:connection, client_type: Connection::TYPE_LATENCY_TESTER, client_id: latency_tester.client_id) if evaluator.make_connection
      latency_tester.save
    end
  end

end