import java.util.*;

public class Searcher implements SearchOperations{

	private final Map<String, Recording> recByTitle = new HashMap<>();
	private SortedMap<Integer, Set<Recording>> recByYear = new TreeMap<>();
	private Map<String, Set<Recording>> recByArtis = new HashMap<>();
	private Map<String, Set<Recording>> recByGenres = new HashMap<>();
	
	//Gamla
	//private final Map<String, Set<Recording>> recordingHashByArtist = new HashMap<>();
	//private final Map<String, Set<Recording>> recordingTreeByTitle = new TreeMap<>();

	public Searcher(Collection<Recording> data) {
		
		Collection<Recording> recordings = data;
		
		//Loopa igenom och lägg till i olika set
		for(Recording r: recordings) {
			recByTitle.put(r.getTitle(), r);
			
			//Lägg till år i map med nestad set
			Set<Recording> set = recByYear.get(r.getYear());
			if(set == null) {
				set = new HashSet<>();
				recByYear.put(r.getYear(), set);
			}
			set.add(r);
			
			//Lägg till artist i map nestad set
			Set<Recording> sameArtist = recByArtis.get(r.getArtist());
			if(sameArtist == null) {
				sameArtist = new HashSet<>();
				recByArtis.put(r.getArtist(), sameArtist);
			}
			sameArtist.add(r);
			
			//Lägg till genre i map nestad set
			for (String genre: r.getGenre()) {
				Set<Recording> sameGenre = recByGenres.get(genre);
				if(sameGenre == null) {
					sameGenre = new HashSet<>();
					recByGenres.put(genre, sameGenre);
				}
				sameGenre.add(r);
			}//for genre

			
		} //for r
	}	

	@Override
	public long numberOfArtists() {
		return (long) recByArtis.size(); //Returnera storleken
	}
	
	@Override
	public long numberOfGenres(){
		return (long) recByGenres.size();
	}

	@Override
	public long numberOfTitles(){
		return (long) recByTitle.size();
	}

	@Override
	public boolean doesArtistExist(String name){
		return recByArtis.containsKey(name); //kontrollea om namnet finns som nyckel i hashset
	}

	@Override
	public Collection<String> getGenres(){
		return Collections.unmodifiableCollection(recByGenres.keySet()); //returnerar omodfierbar samling av genrer 
	}

	@Override
	public Recording getRecordingByName(String title) {
		return recByTitle.get(title);
	}

	@Override
	public Collection<Recording> getRecordingsAfter(int year){
		Set<Recording> ret = new HashSet<>();
		
		for (Set<Recording> recs : recByYear.tailMap(year).values()) {
			ret.addAll(recs);
		}
		
		return Collections.unmodifiableCollection(ret); 
	}

	@Override
	public SortedSet<Recording> getRecordingsByArtistOrderedByYearAsc(String artist){
		
		SortedSet<Recording> set = new TreeSet<>(Recording.getYearCmp());
		set.addAll(recByArtis.get(artist));
		
		return Collections.unmodifiableSortedSet(set); 
	}

	@Override
	public Collection<Recording> getRecordingsByGenre(String genre){
		return Collections.unmodifiableCollection(recByGenres.getOrDefault(genre, Collections.emptySet())); 
	}

	@Override
	public Collection<Recording> getRecordingsByGenreAndYear(String genre, int yearFrom, int yearTo) {
	
		Set<Recording> ret = new HashSet<>();
		Set<Recording> sameGengre = recByGenres.get(genre);
		for(Set<Recording> recs : recByYear.subMap(yearFrom, yearTo + 1).values()){
			recs.retainAll(sameGengre);
			ret.addAll(recs);
		}
		return Collections.unmodifiableCollection(ret);
	}
	
	@Override
	public Collection<Recording> offerHasNewRecordings(Collection<Recording> offered){
		Set<Recording> ret = new HashSet<>();
		ret.addAll(offered);
		
		for (Set<Recording> rec : recByYear.values()) {
			ret.removeAll(rec);
		}
		
		if (ret.isEmpty()) {
			return Collections.emptySet();
		}
		
		return Collections.unmodifiableCollection(ret);
	}
	
	@Override
	public Collection<Recording> optionalGetRecordingsFrom(int year) {
		
		//Kollar om värdet finns annars så returnerar det vi sägger till den att göra, vilket i detta fall är en empty set
		return Collections.unmodifiableCollection(recByYear.getOrDefault(year, Collections.emptySet()));
	}
	
}