func Search(show *store.Show) ([]Torrent, error) {
	// torrents holds the torrents to complete a serie
	var torrents []Torrent

	// TODO perhaps mashing season and episode jobs together is a bad idea
	queryJobs := createQueryJobs(show)
	for _, queryJob := range queryJobs {
		torrent, err := executeJob(queryJob)
		if err != nil {
			continue
		}

		torrent.AssociatedMedia = queryJob.media
		queryJob.snippet.Score = torrent.seeds
		// *ouch* this type switch is ugly
		switch queryJob.media.(type) {
		case *store.Season:
			show.StoreSeasonSnippet(queryJob.snippet)
		case *store.Episode:
			show.StoreEpisodeSnippet(queryJob.snippet)
		default:
			panic("unknown media type")
		}
		torrents = append(torrents, *torrent)
	}

	return torrents, nil
}

func selectEpisodeSnippet(show *store.Show) store.Snippet {
	if len(show.QuerySnippets.ForEpisode) == 0 || isExplore() {
		// select random snippet
		var snippets []store.Snippet
		for k, _ := range episodeQueryAlternatives {
			for _, morpher := range titleMorphers {
				snippets = append(
					snippets,
					store.Snippet{
						Score:         0,
						TitleSnippet:  morpher(show.Title),
						FormatSnippet: k,
					},
				)
			}
		}
		snippet := snippets[rand.Intn(len(snippets))]
		log.WithFields(
			log.Fields{
				"title_snippet":  snippet.TitleSnippet,
				"format_snippet": snippet.FormatSnippet,
			}).Debug("Random snippet")
		return snippet
	}

	// select the current best
	return show.BestEpisodeSnippet()
}

func TestStoreEpisodeSnippet(t *testing.T) {
	show := store.Show{}
	snippet := store.Snippet{Score: 123, TitleSnippet: "abc", FormatSnippet: "sxs"}
	show.StoreEpisodeSnippet(snippet)

	assert.Equal(t, snippet, show.QuerySnippets.ForEpisode[0])
}

// SearchTorrents provides some feedback to the user and searches for torrents
// for the pending items.
func SearchTorrents(show *store.Show) ([]torrents.Torrent, error) {
	fmt.Printf(
		"Searching for %d torrents",
		len(show.PendingSeasons())+len(show.PendingEpisodes()),
	)

	c := startProgressBar()
	defer stopProgressBar(c)

	return torrents.Search(show)
}

func TestEpisodes(t *testing.T) {
	season1 := &store.Season{Episodes: []*store.Episode{
		{Episode: 1},
		{Episode: 2}}}
	season2 := &store.Season{Episodes: []*store.Episode{
		{Episode: 1},
		{Episode: 2}}}
	s := store.Show{Seasons: []*store.Season{season1, season2}}

	if len(s.Episodes()) != 4 {
		t.Error("Expected to have 4 episodes, got: ", len(s.Episodes()))
	}
}

// DisplayPendingEpisodes shows, on stdout, the episodes pending for a
// particular show.
func DisplayPendingEpisodes(show *store.Show) {
	xs := show.PendingSeasons()
	for _, x := range xs {
		fmt.Printf("Pending: %s season %d\n", show.Title, x.Season)
	}
	ys := show.PendingEpisodes()
	if len(ys) > 10 {
		fmt.Println("<snip>")
		ys = ys[len(ys)-10:]
	}
	for _, y := range ys {
		fmt.Printf("Pending: %s season %d episode %d\n", show.Title, y.Season(), y.Episode)
	}
}

func queriesForEpisodes(show *store.Show) []queryJob {
	episodes := show.PendingEpisodes()
	sort.Sort(store.ByAirDate(episodes))
	min := math.Min(float64(len(episodes)), float64(batchSize))

	queries := []queryJob{}
	for _, episode := range episodes[0:int(min)] {
		snippet := selectEpisodeSnippet(show)

		query := episodeQueryAlternatives[snippet.FormatSnippet](snippet.TitleSnippet, episode)
		queries = append(queries, queryJob{
			snippet: snippet,
			query:   query,
			media:   episode,
		})
	}
	return queries
}

func queriesForSeasons(show *store.Show) []queryJob {
	queries := []queryJob{}
	for _, season := range show.PendingSeasons() {
		// ignore Season 0, which are specials and are rarely found and/or
		// interesting.
		if season.Season == 0 {
			continue
		}

		snippet := selectSeasonSnippet(show)

		query := seasonQueryAlternatives[snippet.FormatSnippet](snippet.TitleSnippet, season)
		queries = append(queries, queryJob{
			snippet: snippet,
			query:   query,
			media:   season,
			season:  season.Season,
		})
	}
	return queries
}

func selectSeasonSnippet(show *store.Show) store.Snippet {
	if len(show.QuerySnippets.ForSeason) == 0 || isExplore() {
		// select random snippet
		var snippets []store.Snippet
		for k, _ := range seasonQueryAlternatives {
			for _, morpher := range titleMorphers {
				snippets = append(
					snippets,
					store.Snippet{
						Score:         0,
						TitleSnippet:  morpher(show.Title),
						FormatSnippet: k,
					},
				)
			}
		}
		return snippets[rand.Intn(len(snippets))]
	}

	// select the current best
	return show.BestSeasonSnippet()
}

func addSeason(show *store.Show, season Season) {
	newSeason := store.Season{
		Season: season.Season,
	}
	for _, episode := range season.Episodes {
		newEpisode := store.Episode{
			Episode: episode.Episode,
			AirDate: episode.AirDate,
			Title:   episode.Title,
			Pending: true,
		}
		newSeason.Episodes = append(newSeason.Episodes, &newEpisode)
	}

	show.Seasons = append(show.Seasons, &newSeason)
}

func TestDisplayTitle(t *testing.T) {
	s := store.Show{Title: "bar"}
	if s.DisplayTitle() != s.Title {
		t.Error("Expected DisplayTitle to return the Title, got: ", s.DisplayTitle())
	}
}

func TestPendingItems(t *testing.T) {
	show := store.Show{}
	episodes := []*store.Episode{
		{Pending: true},
		{Pending: true},
		{Pending: true},
	}
	season1 := store.Season{Season: 1, Episodes: episodes}
	show.Seasons = append(show.Seasons, &season1)
	if len(show.PendingSeasons()) != 0 {
		t.Error("All episodes are pending but it's from the last seasons thus no seasons should be returned, got:", len(show.PendingSeasons()))
	}
	if len(show.PendingEpisodes()) != 3 {
		t.Error("All episodes are pending, got:", len(show.PendingEpisodes()))
	}

	episodes = []*store.Episode{
		{Pending: true},
		{Pending: true},
	}
	season2 := store.Season{Season: 2, Episodes: episodes}
	show.Seasons = append(show.Seasons, &season2)
	if len(show.PendingSeasons()) != 1 {
		t.Error("Expected 2 items representing the episodes of the last season and 1 item representing the first season.")
	}
	if len(show.PendingEpisodes()) != 2 {
		t.Error("Expected 2 items representing the episodes of the last season and 1 item representing the first season.")
	}
}