SongBookApp

import java.util.*;

public class SongBookApp {

    /*
    Aufgabe: Umgang mit Klassen und Objekten, sowie vorgefertigten Datenstrukturen.

        Ergänzen Sie fehlende Teile der Klassen Melody und SongBook entsprechend den Kommentaren
        an den mit TODO gekennzeichneten Stellen.
        Sonstige Anforderungen: Es sollen keine zusätzlichen Methoden oder Objektvariablen
        implementiert werden.
        Hinweis: 'SongBook' kann auch implementiert werden, ohne dass 'Melody' implementiert
        wird. In diesem Fall kann kann die Ausgabe von den angegebenen Sollausgaben abweichen.

    Punkte (maximal 34):
        21 Punkte in Summe für Klasse 'Melody':
            7 Punkte für 'copy'
            2 Punkte für 'setBPM'
            7 Punkte für 'transpose'
            5 Punkte für 'toString',
        13 Punkte für Klasse 'SongBook':
            4 Punkte für den Konstruktor und Variablen
            6 Punkte für 'addMelody'
            3 Punkte für 'getMelody'

    */

    // Diese Methode steht Ihnen zum Testen zur Verfügung. Ihr Inhalt wird
    // nicht beurteilt.
    public static void main(String[] args) {

        // Überprüft die korrekte Basisimplementierung der Klasse Melody:
        // 'setBPM' und 'toString'
        // Erwarteter Output:
        // do 2 fa 4 si 6
        // 6.0 seconds
        // do 2 fa 4 si 6
        // 4.5 seconds
        Melody m1 = new Melody(120);
        m1.addNote(new Note(0, 2));
        m1.addNote(new Note(3, 4));
        m1.addNote(new Note(6, 6));
        System.out.println(m1);
        m1.setBPM(160);
        System.out.println(m1);

        // Überprüft die korrekte Umsetzung der Teilaufgabe 'transponieren'.
        // Erwarteter Output:
        // mi 2 la 4 re 6
        // 6.0 seconds
        m1 = new Melody(120);
        m1.addNote(new Note(0, 2));
        m1.addNote(new Note(3, 4));
        m1.addNote(new Note(6, 6));
        m1.transpose(2);
        System.out.println(m1);

        // Überprüft die korrekte Umsetzung der Teilaufgabe 'kopieren'.
        // Erwarteter Output:
        // re 4 mi 1 la 1
        // 6.0 seconds
        // re 4 mi 1 la 1
        // 6.0 seconds
        m1 = new Melody(60);
        m1.addNote(new Note(0, 2));
        m1.addNote(new Note(3, 4));
        m1.addNote(new Note(1, 4));
        m1.addNote(new Note(2, 1));
        m1.addNote(new Note(5, 1));
        Melody m2 = m1.copy(2,5);
        System.out.println(m2);
        m1.transpose(1);
        System.out.println(m2);


        // Überprüft die korrekte Implementierung des Songbooks.
        // Erwarteter Output:
        // true
        // true
        // true
        // false
        // true
        m1 = new Melody(60);
        m1.addNote(new Note(0, 2));
        m1.addNote(new Note(3, 4));
        SongBook sb1 = new SongBook();
        System.out.println(sb1.addMelody("Testtitel", m1));
        System.out.println(sb1.addMelody("Another Song", new Melody(1)));
        m2 = sb1.getMelody("Testtitel");
        System.out.println(m1 == m2);
        System.out.println(sb1.addMelody("Testtitel", new Melody(2)));
        Melody m3 = sb1.getMelody("Testtitel");
        System.out.println(m1 == m3);

        // Neuer Testfall
        System.out.println(sb1.getMelody("bla"));

    }
}

// Die Klasse Note ist fertig vorgegeben und repräsentiert eine Note. 
// Eine Note ist der kleinste Bestandteil einer Melodie und ist 
// charakterisiert durch Höhe und Länge. Die Notenlänge
// wird in Schlägen angegeben. Es gibt insgesamt 7 Noten. In aufsteigender
// Reihenfolge: do - re - mi - fa - sol - la - si. Die Notennamen haben
// numerische Entsprechungen.
// 
// do re mi fa sol la si 
//  0  1  2  3   4  5  6
class Note {
	
	private int noteIndex;
	private int beats;
	
	public static final String[] steps = {"do","re","mi","fa","sol","la","si"};
	
	// Initialisiert die neue Instanz von Note. 'beats' gibt die Länge der Note an. Die
	// Höhe der Note wird als numerischer Wert angegeben ('noteIndex').
	public Note(int noteIndex, int beats) {
		
		this.noteIndex = noteIndex;
		this.beats = beats;
		
	}
	
	// Initialisiert diese Note mit den Werten der angegebenen Note
	// (initialisiert eine Kopie).
	public Note(Note note) {
		
		this(note.noteIndex, note.beats);
		
	}
	
	// gibt die Notenlänge in Schlägen zurück.
	public int getBeats() {
		
		return this.beats; 
		
	}
	
	// Transponiert die Note um den angegebenen Wert nach oben oder nach unten.
	// Ist die gespeicherte Note beispielsweise do, so lauten diese nach Aufruf
	// der Methode mit steps=3 fa. Dabei liegt ein zyklischer Abschluss vor: Die
	// sieben Noten lauten do - re - mi - fa - sol - la - si. Auf die letzte
	// Note si folgt wieder do.
	public void transpose(int steps) {
		
		this.noteIndex += steps;
		
		while(this.noteIndex < 0) {
			this.noteIndex += Note.steps.length;
		}
		
		this.noteIndex %= Note.steps.length;
		
	}
	
	// gibt den Namen der Note gefolgt von einem Leerzeichen und deren Länge in
	// Schlägen zurück. Format (Beispiel):
    // do 3
	public String toString() {
		
		return Note.steps[this.noteIndex] + " " + beats;
		
	}
	
}

// Diese Klasse repräsentiert eine Melodie, die aus mehreren Noten besteht. Die
// Noten werden als Array gespeichert. Verschiedene Methoden
// ermöglichen das Hinzufügen von Noten, das Kopieren von Notenfolgen und das
// Transponieren der Melodie. 
class Melody {

    // Folgende Objektvariablen sind vorgegeben und sollen nicht verändert werden.
    // Es sind keine weiteren Objektvariablen zulässig.
	private Note[] notes;
	private int bpm;
	
	// Konstruktor (bereits gegeben):
	// initialisiert diese Instanz von Melody und speichert 
	// das übergebene Tempo (beatsPerMinute, Schläge pro Minute).
    // Vorbedingung: beatsPerMinute > 0
	public Melody(int beatsPerMinute) {

		this.bpm=beatsPerMinute;
        this.notes = new Note[0]; //zu Beginn eine leere Notenfolge

	}
	
	// Fügt am Ende der Melodie die angegebene Note hinzu. (bereits gegeben)
	public void addNote(Note note) {

		Note[] notes = new Note[this.notes.length+1];
		System.arraycopy(this.notes,0,notes,0,this.notes.length);
		notes[notes.length-1] = note;
		this.notes = notes;

	}
	
	// Kopiert eine Folge von Noten und gibt diese als neue Melodie (Melody)
	// zurück. Die neue Melodie hat dabei das gleiche Tempo, die kopierten Noten
	// sollen unabhängige Kopien der ursprünglichen Noten sein. Die neue Melodie
	// beinhaltet die Noten zwischen inklusive beginIndex und exklusive
	// endIndex, hat also die Länge endIndex - beginIndex. Besteht die
	// gespeicherte Melodie beispielsweise aus den Tönen do - re - mi - fa -
	// sol, so lautet die neue Melodie bei Aufruf der Methode mit den Parametern
	// beginIndex=1 und endIndex=4 re - mi - fa und hat die Länge 3.
    // Vorbedingung: Die angegebenen Indizes sind gültig.
	public Melody copy(int beginIndex, int endIndex) {

        Melody melody = new Melody(bpm);

        for (int i = beginIndex; i < endIndex; i++) {
            Note oldNote = notes[i];
            Note newNote = new Note(oldNote);

            melody.addNote(newNote);
        }

        return melody;
		
		//TODO: Implementieren Sie diese Methode
	}
	
	// Setzt das Tempo der Melodie auf den übergebenen Wert (bpm, Schläge pro
	// Minute).
	// Vorbedingung: beatsPerMinute > 0
	public void setBPM(int beatsPerMinute) {
		this.bpm = beatsPerMinute;
		//TODO: Implementieren Sie diese Methode
		
	}
	
	// Transponiert alle Noten der Melodie um den gleichen Wert nach oben oder
	// nach unten (siehe dazu die entsprechende Methode der Klasse Note).
	public void transpose(int steps) {
		for (Note note : notes) {
            note.transpose(steps);
        }
		//TODO: Implementieren Sie diese Methode
		
	}
	
	// Gibt die Töne der Melodie in der Form Notenname gefolgt von einem
	// Leerzeichen und der Notenlänge (in Schläge pro Minute) zurück. Zwischen
	// zwei Noten steht jeweils ein Leerzeichen, alle Noten stehen in der
	// gleichen Zeile. In einer neuen Zeile wird die Dauer der Melodie in
	// Sekunden ausgegeben. Ist die gespeicherte Melodie beispielsweise do 1 re
	// 1 mi 2 fa 4, ist die Gesamtdauer 8 Schläge. Ist das Tempo der Melodie 80
	// Schläge pro Minute, so beträgt die Länge 6 Sekunden.
	//  
	// do 1 re 1 mi 2 fa 4
	// 6.0 seconds
	public String toString() {
        String string = "";

        int beats = 0;
        for (Note note : notes) {
            string += note.toString();
            string += " ";
            beats += note.getBeats();
        }

        double length = 60.0 / ((double)bpm / (double)beats);

        string += "\n" + length + " seconds";

        return string;
		
		//TODO: Implementieren Sie diese Methode
	}
	
}

// Diese Klasse repräsentiert ein Notenbuch. Ein Notenbuch enthält mehrere
// Melodien und speichert diese in entsprechender Form. Sie stellt Methoden zur
// Verfügung um Melodien hinzuzufügen oder um auf gespeicherte Melodien
// zuzugreifen. 
class SongBook {
	
	//TODO: Deklarieren Sie hier die Objektvariablen.
    private HashMap<String, Melody> melodies;
	

	// Initialisiert die Instanz von SongBook.
	public SongBook() {
		melodies = new HashMap<String, Melody>();
		//TODO: Implementieren Sie diese Methode.
	}
	
	// Speichert im SongBook unter dem angegebenen Titel (title) eine Melodie 
	// (melody) und gibt true zurück. Gibt es jedoch im SongBook unter diesem 
	// Namen bereits eine Melodie, so wird die übergebene Melodie nicht 
	// hinzugefügt, die Methode gibt false zurück.
	public boolean addMelody(String title, Melody melody) {
        if (!melodies.containsKey(title)) {
            melodies.put(title, melody);
            return true;
        }
		
		//TODO: Implementieren Sie diese Methode.
		return false; //TODO: Diese Zeile entfernen oder in Lösung integrieren.
	}
	
	
	// Gibt die unter dem angegeben Titel gespeicherte Melodie zurück. 
	// Existiert keine Melodie unter diesem Titel, so wird null zurückgegeben.
	public Melody getMelody(String title) {

        return melodies.get(title);
		
		//TODO: Implementieren Sie diese Methode.
	}
	
}