ims

#!/usr/bin/env ruby
require "minitest/autorun"
require "minitest/spec"

require "pstore"
require "./music_storage"



class IMS
	def initialize(storage_name)
		#initialize the terminate flag
		#if @terminate flag is true, then mainLoop stops
		@terminate = false
		@storage = MusicStorage.new(storage_name)
	end

	def main_loop()
		#if @terminate flag is true, end loop
		while !@terminate
		    print "> "
		    parse_command(gets.chomp)
		end
	end

	# The main parser for all the commands
	def parse_command(command)
		# i following an re to ignore cases
		if /^exit$/i =~ command
			exit()
		elsif /^help$/i =~ command
			help()
		elsif /^info$/i =~ command
			summary()
		elsif /^info track \s*(.+)$/i =~ command
			track_number = $~[1]
			track_info(track_number)
		elsif /^info artist \s*(.+)$/i =~ command
			artist_id = $~[1]
			artist_info(artist_id)
		# Using (?-i) to preserve the case of artist and track names
		elsif /^add artist \s*((?-i).+)$/i =~ command
			artist_name = $~[1]
			add_artist(artist_name)
		elsif /^add track \s*((?-i).+) by (\w+)$/i =~ command
			track_name = $~[1]
			artist_id = $~[2]
			add_track(track_name, artist_id)
		elsif /^play track \s*(.+)$/i =~ command
			track_number = $~[1]
			play_track(track_number)
		elsif /^count tracks by \s*(.+)$/i =~ command
			artist_id = $~[1]
			count_tracks(artist_id)
		elsif /^list tracks by \s*(\w+)$/i =~ command
			artist_id = $~[1]
			list_tracks(artist_id)
		else
			puts "Command not recognized, enter \'help\' for a list of supported commands and their usages."
		end
	end

	def exit()
		#save state and change flag @terminate to true
    @storage.save
		@terminate = true
	end
    
    # display the help message
	def help()
		help = "Commands for IMS:\n"\
           "1. help - Display this help message\n"\
           "2. exit - Save the current state and exit the program\n"\
           "3. info - Display a summary of the current status\n"\
           "4. info track <track_number> - Display some info about a track. \n"\
           "                               Example: info track 2\n"\
           "5. info artist <artist_id> - Display some info about an artist. \n"\
           "                             Example: info track jh\n"\
           "6. add artist <artist_name> - Add an artist to ims. \n"\
           "                              Example: add artist Joe Hisaishi\n"\
           "7. add track <track_name> by <artist_id> - Add a track for an existing artist. \n"\
           "                                           Example: add track One Summer's Day by jh\n"\
           "8. play track <track_number> - Play a track, IMS will record it as played. \n"\
           "                               Example: play track 2\n"\
           "9. count tracks by <artist_id> - Count the number of tracks by an given artist.\n"\
           "                                 Example: count tracks by jh\n"\
           "10. list tracks by <artist_id> - Display all the tracks by the given artist.\n"\
           "                                 Example: list tracks by jh\n"

		puts help
	end

	def summary()
		#display a summary of the current state
		puts "Total number of tracks #{@storage.get_total_track_count}"
		puts "Total number of artists #{@storage.get_total_artist_count}"
		puts "Last played tracks:"
		last_played = @storage.get_last_played
		last_played.each do |track|
			artist = @storage.get_artist(track.artist_id)
			puts "\t#{track.name} by #{artist.name}"
		end
	end

    # List the information about a given track
	def track_info(track_number)
		# if track_number is in a legal format
		if is_track_number(track_number)
			# check if the track is in the storage or not
			if @storage.has_track(track_number)
				track = @storage.get_track(track_number)
				artist = @storage.get_artist(track.artist_id)
				info = "Info about track #{track_number}:\n"\
				       "\tName: #{track.name}\n"\
				       "\tArtist: #{artist.name}\n"\
				       "\tArtist ID: #{artist.id}\n"
				puts info
			else
				puts "Error: Unknown track number #{track_number}"
			end
		end
	end

    # List the information about a given artist
	def artist_info(artist_id)
		if is_artist_id(artist_id)
			if @storage.has_artist(artist_id)
				artist = @storage.get_artist(artist_id)
				info = "Info about artist #{artist_id}:\n"\
				       "\tArtist Name: #{artist.name}\n"\
				       "\tArtist ID: #{artist.id}\n"\
				       "\tNumber of Tracks: #{artist.tracks.size}"

				puts info
			else
				puts "Error: Unknown artist ID #{artist_id}"
			end
		end
	end

    # add a track to the storage
	def add_track(track_name, artist_id)
		# check if the artist ID exists
		if !@storage.has_artist(artist_id)
			puts "Error: Unrecognized artist ID"
		else
		  number = make_track_number
		  @storage.add_track(track_name, number, artist_id)
		  puts "Added #{track_name} as track, track number is #{number}"
		end
	end

    # add an artist to the storage
    # artist doesn't have any tracks associated at this point
	def add_artist(artist_name)
		id = makeartist_id(artist_name)
		@storage.add_artist(artist_name, id)
		puts "Added #{artist_name} as artist, artist ID is #{id}"
	end

    # record the given track as played
	def play_track(track_number)
		@storage.play_track(track_number)
	end

    # count the total number of tracks in storage for the given artist
	def count_tracks(artist_id)
		#display the number of tracks know by the specified artist
		if is_artist_id(artist_id)
			if @storage.has_artist(artist_id)
		      tracks = @storage.get_tracks_by(artist_id)
		      puts "Artist #{artist_id} has #{tracks.size} track(s)."
		    else
		    	puts "Error: Unrecognized artist ID"
		    end
		end
	end

    # list all the tracks by number and name, for the given artist
	def list_tracks(artist_id)
		# check if the artist ID exists
		if !@storage.has_artist(artist_id)
			puts "Error: Unrecognized artist ID"
		else
			artist = @storage.get_artist(artist_id)
			artist_tracks = artist.tracks
			puts "Tracks by #{artist.name}:"
			artist_tracks.each do |track|
				puts "\tTrack ##{track.number} - #{track.name}"
			end
		end
	end


	# generate an id for a given artist name
	def makeartist_id(artist_name)
		num = 0
		splitName = artist_name.downcase.split
		initials = splitName.map {|word| word[0]}.join
		id = initials
		# if the initials already exist in storage, add a number to it.
		if @storage.has_artist(id)
			id += num.to_s
			num += 1
		end
		# keep increasing the number until the id doesn't exist in storage.
		while @storage.has_artist(id)
			id = initials + num.to_s
			num += 1
		end

		return id
	end

	# track number is just the total number of tracks in storage + 1
	def make_track_number()
		number = @storage.get_total_track_count + 1
		# Convert number to string, so that in @storage, track number is stored as a string
		return number.to_s
	end

	# methods for checking the fomats of track numbers or artist IDs.
	def is_track_number(track_number)
		if /^\d+$/ =~ track_number
			return true
		else
			puts "Invalid track number, must be digits." 
			return false
		end
	end

	def is_artist_id(artist_id)
		if /^\w+$/ =~ artist_id
			return true
		else
			puts "Invalid artist ID, must be a series of alphanumerical characters." 
			return false
		end
	end
end

ims = IMS.new("music_storage.pstore")
ims.main_loop()


describe "Parsing test" do
	it "should parse commands correctly" do
		t = IMS.new("test.pstore")

		t.makeartist_id("Test Artist").must_equal "ta"

		t.parse_command("Add Artist Test Artist")
		t.makeartist_id("Test Artist").must_equal "ta0"

		t.parse_command("add Track Test Track by ta")
		t.parse_command("ADD track Test Track 1 by tz")
		t.parse_command("play track 1")
		t.parse_command("play track 1")
		t.parse_command("play track 1")
		t.parse_command("play track 1")
    t.parse_command("exit")

		s = MusicStorage.new("test.pstore")
		s.get_tracks_by("ta").size.must_equal 1
		s.get_last_played.size.must_equal 3
	end
end