class Discogs
  
  def self.artists
    self.get_nodes('tmp/data/discogs_artists.xml', 'artist') do |node|
      artist = Artist.new(
        :name => (node.css('name').first.text),
        :pic_url => (node.css('images > image[type="primary"]').first.attr('uri') unless node.css('images > image[type="primary"]').empty?),
        :status => 1
      )
      artist.save
      node.css('namevariations > name, aliases > name').each do |v|
        ArtistAlias.new(
          :artist_id => artist.id,
          :name => v.text
        ).save
      end
    end
  end
  
  def self.releases
    self.get_nodes('tmp/data/discogs_releases.xml', 'release') do |node|
      
      # Defining artist
      main_artist = nil
      unless node.css('artists > artist > name').empty?
        main_artist = Artist.find_or_create_by_name(node.css('artists > artist > name').first.text)
      end
      
      # Creating album
      album = Album.new(
        :name => (node.css('title').first.text unless node.css('title').empty?),
        :artist_id => (main_artist.id unless main_artist.nil?),
        :year => (node.css('released').first.text.split('-').first.to_i unless node.css('released').empty?),
        :status => 1,
        :master => (not node.css('master_id').empty?)
      )
    
      # Parsing image
      unless node.css('images > image[type="primary"]').empty?
        album.pic_url = node.css('images > image[type="primary"]').first.attr('uri')
        album.has_pic = 1
      else
        album.has_pic = 0
      end
      
      album.save ## ## ##
      
      # Defining formats
      formats = node.css('formats > format > descriptions > description').each do |f|
        format = ReleaseFormat.find_or_create_by_name(f.text)
        if format.hash.nil?
          format.hash = f.text.scan(/\w/).join().downcase
          format.save
        end
        AlbumFormat.new(
          :album_id => album.id,
          :release_format_id => format.id
        ).save
      end
    
      # Defining genres
      unless node.css('genres > genre').empty?
        node.css('genres > genre').each do |g|
          genre = Genre.find_or_create_by_name(g.text)
          AlbumGenre.new(
            :album_id => album.id,
            :genre_id => genre.id
          ).save
        end
      end
      
      # Defining styles
      unless node.css('styles > style').empty?
        node.css('styles > style').each do |s|
          style = Style.find_or_create_by_name(s.text)
          AlbumStyle.new(
            :album_id => album.id,
            :style_id => style.id
          ).save
        end
      end
    
      # Writing tracklist
      unless node.css('tracklist > track').empty?
        node.css('tracklist > track').each do |t|
          track = Track.new(
            :album_id => album.id,
            :name => (t.css('title').first.text unless t.css('title').empty?),
            :position => (t.css('position').first.text.to_i(36) unless t.css('position').empty?),
            :country => (node.css('country').first.text unless node.css('country').empty?),
            :length => (self.duration_to_length(t.css('duration').first.text) unless t.css('duration').empty?)
          )
          track.save
          
          if t.css('artists > artist').empty?
            TrackArtist.new(
              :track_id => track.id,
              :artist_id => (main_artist.id unless main_artist.nil?),
              :main => true
            ).save
          else
            t.css('artists > artist').each_with_index do |a, i|
              t_artist = Artist.find_or_create_by_name(a.css('name').first.text)
              TrackArtist.new(
                :track_id => track.id,
                :artist_id => t_artist.id,
                :main => (i == 0),
                :join => a.css('join').first.text
              ).save
            end
          end
          
        end
      end
      
    end
  end
  
  private
  
  def self.get_nodes filename, nodename, &block
    File.open(filename) do |file|
      Nokogiri::XML::Reader.from_io(file).each do |node|
        if node.name == nodename and node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
          yield(Nokogiri::XML(node.outer_xml).root)
        end
      end
    end
  end
  
  def self.duration_to_length duration
    duration = duration.split(':')
    duration[0].to_i * 60 + duration[1].to_i
  end
  
end