require 'aasm'

module JamRuby
  class Connection < ActiveRecord::Base


    attr_accessor :joining_session

    self.primary_key = 'id'

    belongs_to :user, :class_name => "JamRuby::User"
    belongs_to :music_session, :class_name => "JamRuby::MusicSession"
    has_many :tracks, :class_name => "JamRuby::Track", :inverse_of => :connection, :foreign_key => 'connection_id', :dependent => :delete_all


    validates :as_musician, :inclusion => {:in => [true, false]}
    validates :client_type, :inclusion => {:in => ['client', 'browser']}
    validate :can_join_music_session, :if => :joining_session?
    after_save :require_at_least_one_track_when_in_session, :if => :joining_session?
    after_create :did_create
    after_save :report_add_participant

    include AASM
    IDLE_STATE = :idle
    CONNECT_STATE = :connected
    STALE_STATE = :stale
    EXPIRED_STATE = :expired

    aasm do
      state IDLE_STATE, :initial => true
      state CONNECT_STATE
      state STALE_STATE
      state EXPIRED_STATE

      event :connect do
        transitions :from => IDLE_STATE, :to => CONNECT_STATE
        transitions :from => STALE_STATE, :to => CONNECT_STATE
      end
      event :stale do
        transitions :from => CONNECT_STATE, :to => STALE_STATE
        transitions :from => IDLE_STATE, :to => STALE_STATE
      end
      event :expire, :after => :did_expire do
        transitions :from => CONNECT_STATE, :to => EXPIRED_STATE
        transitions :from => STALE_STATE, :to => EXPIRED_STATE
        transitions :from => IDLE_STATE, :to => EXPIRED_STATE
      end
    end

    def state_message
      case self.aasm_state.to_sym
        when CONNECT_STATE
        'Connected'
        when STALE_STATE 
        'Stale'
        else
        'Idle'
      end
    end

    def did_expire
      self.destroy
    end

    def joining_session?
      joining_session
    end
    
    def can_join_music_session

      # puts "can_join_music_session: #{music_session_id} was #{music_session_id_was}" if music_session_id_changed?

      if music_session_id_changed? and !(music_session_id_was.nil? or music_session_id_was.blank?)
        errors.add(:music_session, ValidationMessages::CANT_JOIN_MULTIPLE_SESSIONS)
        return false
      end

      if music_session.nil?
        errors.add(:music_session, ValidationMessages::MUSIC_SESSION_MUST_BE_SPECIFIED)
        return false
      end

      if as_musician
        unless self.user.musician
          errors.add(:as_musician, ValidationMessages::FAN_CAN_NOT_JOIN_AS_MUSICIAN)
          return false
        end

        if music_session.musician_access
          if music_session.approval_required
            unless music_session.creator == user || music_session.invited_musicians.exists?(user)
              errors.add(:approval_required, ValidationMessages::INVITE_REQUIRED)
              return false
            end
          end
        else
          unless music_session.creator == user || music_session.invited_musicians.exists?(user)
            errors.add(:musician_access, ValidationMessages::INVITE_REQUIRED)
            return false
          end
        end
      else
        unless self.music_session.fan_access
          # it's someone joining as a fan, and the only way a fan can join is if fan_access is true
          errors.add(:fan_access, ValidationMessages::FANS_CAN_NOT_JOIN)
          return false
        end
      end

      if music_session.is_recording?
        errors.add(:music_session, ValidationMessages::CANT_JOIN_RECORDING_SESSION)
      end

      # unless user.admin?
      #   num_sessions = Connection.where(:user_id => user_id)
      #     .where(["(music_session_id IS NOT NULL) AND (aasm_state != ?)",EXPIRED_STATE.to_s])
      #     .count
      #   if 0 < num_sessions
      #     errors.add(:music_session, ValidationMessages::CANT_JOIN_MULTIPLE_SESSIONS)
      #     return false;
      #   end
      # end 

      return true
    end


    # decides if a given user can access this client with p2p messaging
    # the answer is yes if the user is in the same music session
    def access_p2p?(user)
      return self.music_session.users.exists?(user)
    end

    def did_create
      self.user.update_lat_lng(self.ip_address) if self.user && self.ip_address
    end

    def report_add_participant
      if self.music_session_id_changed? && 
          self.music_session.present? && 
          self.connected? && 
          self.as_musician? &&
          0 < (count = self.music_session.connected_participant_count)
        GoogleAnalyticsEvent.report_session_participant(count)
      end
      true
    end

    def join_the_session(music_session, as_musician, tracks)
      self.music_session_id = music_session.id
      self.as_musician = as_musician
      self.joining_session = true
      self.joined_session_at = Time.now
      associate_tracks(tracks) unless tracks.nil?
      self.save
    end

    def associate_tracks(tracks)
      # @log.debug "Tracks:"
      # @log.debug tracks


      unless tracks.nil?
        self.tracks.clear()
        tracks.each do |track|
          t = Track.new
          t.instrument = Instrument.find(track["instrument_id"])
          t.connection = self
          t.sound = track["sound"]
          t.client_track_id = track["client_track_id"]
          t.save # todo what if it fails?
          self.tracks << t
        end
      end
    end


    private

    def require_at_least_one_track_when_in_session
      if tracks.count == 0
        errors.add(:tracks, ValidationMessages::SELECT_AT_LEAST_ONE)
      end
    end

  end
end