diff --git a/README.md b/README.md
index 5150e50f..05def9a9 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+[![Review Assignment Due Date](https://classroom.github.com/assets/deadline-readme-button-22041afd0340ce965d47ae6ef1cefeee28c7c493a6346c4f15d667ab976d596c.svg)](https://classroom.github.com/a/_uV8Mn8f)
 # 📘 Projektarbete: JPA + Hibernate med GitHub-flöde
 
 Projektet genomförs som antingen en Java CLI-applikation eller med hjälp av JavaFX om ni vill ha ett grafiskt gränssnitt.
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 00000000..fcd736ac
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,15 @@
+services:
+  myPod:
+    image: mysql:9.5.0
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_ROOT_HOST: "%"
+      MYSQL_DATABASE: myPodDB
+      MYSQL_USER: user
+      MYSQL_PASSWORD: pass
+    ports:
+      - "3306:3306"
+    volumes:
+      - mypod_data:/var/lib/mysql
+volumes:
+  mypod_data:
diff --git a/pom.xml b/pom.xml
index 909503d0..d68424a5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -45,10 +45,64 @@
         <version>9.5.0</version>
         <scope>runtime</scope>
     </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>2.17.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.datatype</groupId>
+            <artifactId>jackson-datatype-jsr310</artifactId>
+            <version>2.17.1</version>
+        </dependency>
     <dependency>
         <groupId>io.github.classgraph</groupId>
         <artifactId>classgraph</artifactId>
         <version>4.8.184</version>
     </dependency>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-controls</artifactId>
+            <version>25</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-fxml</artifactId>
+            <version>25</version>
+        </dependency>
     </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.13.0</version>
+                <configuration>
+                    <source>25</source>
+                    <target>25</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.openjfx</groupId>
+                <artifactId>javafx-maven-plugin</artifactId>
+                <version>0.0.8</version>
+                <executions>
+                    <execution>
+                        <!-- Default configuration for running with: mvn clean javafx:run -->
+                        <id>default-cli</id>
+                        <configuration>
+                            <mainClass>org.example.MyPod</mainClass>
+                            <launcher>app</launcher>
+                            <jlinkZipName>app</jlinkZipName>
+                            <jlinkImageName>app</jlinkImageName>
+                            <noManPages>true</noManPages>
+                            <stripDebug>true</stripDebug>
+                            <noHeaderFiles>true</noHeaderFiles>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
 </project>
diff --git a/src/main/java/org/example/App.java b/src/main/java/org/example/App.java
index 165e5cd5..b9d5de88 100644
--- a/src/main/java/org/example/App.java
+++ b/src/main/java/org/example/App.java
@@ -1,7 +1,12 @@
 package org.example;
 
+import javafx.application.Application;
+
+
 public class App {
     public static void main(String[] args) {
-        System.out.println("Hello There!");
+
+        Application.launch(MyPod.class, args);
+
     }
 }
diff --git a/src/main/java/org/example/DatabaseInitializer.java b/src/main/java/org/example/DatabaseInitializer.java
new file mode 100644
index 00000000..92eda0f4
--- /dev/null
+++ b/src/main/java/org/example/DatabaseInitializer.java
@@ -0,0 +1,67 @@
+package org.example;
+
+import org.example.entity.Album;
+import org.example.entity.Artist;
+import org.example.entity.Song;
+import org.example.repo.AlbumRepository;
+import org.example.repo.ArtistRepository;
+import org.example.repo.SongRepository;
+
+import java.util.List;
+
+public class DatabaseInitializer {
+
+    private final ItunesApiClient apiClient;
+
+    private final SongRepository songRepo;
+    private final AlbumRepository albumRepo;
+    private final ArtistRepository artistRepo;
+
+    public DatabaseInitializer(ItunesApiClient apiClient, SongRepository songRepo , AlbumRepository albumRepo, ArtistRepository artistRepo) {
+        this.apiClient = apiClient;
+        this.songRepo = songRepo;
+        this.albumRepo = albumRepo;
+        this.artistRepo = artistRepo;
+    }
+
+    public void init() {
+        if (songRepo.count() > 0) { //check if there is data already
+            return;
+        }
+
+        List<String> searches = List.of("the+war+on+drugs",
+            "refused",
+            "thrice",
+            "16+horsepower",
+            "viagra+boys",
+            "geese",
+            "ghost",
+            "run+the+jewels",
+            "rammstein",
+            "salvatore+ganacci",
+            "baroness"
+        );
+        for (String term : searches) {
+            try {
+                apiClient.searchSongs(term).forEach(dto -> {
+                    Artist ar = Artist.fromDTO(dto);
+                    if (!artistRepo.existsByUniqueId(ar)) {
+                        artistRepo.save(ar);
+                    }
+
+                    Album al = Album.fromDTO(dto, ar);
+                    if (!albumRepo.existsByUniqueId(al)) {
+                        albumRepo.save(al);
+                    }
+
+                    Song s = Song.fromDTO(dto, al);
+                    if (!songRepo.existsByUniqueId(s)) {
+                        songRepo.save(s);
+                    }
+                });
+            } catch (Exception e) {
+                throw new RuntimeException("Failed to fetch or persist data for search term: " + term, e);
+            }
+        }
+    }
+}
diff --git a/src/main/java/org/example/ItunesApiClient.java b/src/main/java/org/example/ItunesApiClient.java
new file mode 100644
index 00000000..b0184f0f
--- /dev/null
+++ b/src/main/java/org/example/ItunesApiClient.java
@@ -0,0 +1,63 @@
+package org.example;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+
+import java.net.URI;
+import java.net.URLEncoder;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ItunesApiClient {
+
+    private final HttpClient client;
+    private final ObjectMapper mapper;
+
+    public ItunesApiClient() {
+        this.client = HttpClient.newHttpClient();
+        this.mapper = new ObjectMapper();
+        mapper.registerModule(new JavaTimeModule());
+    }
+
+    public List<ItunesDTO> searchSongs(String term) throws Exception {
+
+        String encodedTerm = URLEncoder.encode(term, StandardCharsets.UTF_8);
+        String url = "https://itunes.apple.com/search?term=" + encodedTerm + "&entity=song&attribute=artistTerm&limit=8";
+
+        HttpRequest request = HttpRequest.newBuilder()
+            .GET()
+            .uri(URI.create(url))
+            .timeout(Duration.ofSeconds(10))
+            .build();
+
+        HttpResponse<String> response =
+            client.send(request, HttpResponse.BodyHandlers.ofString());
+
+        // Kontrollera status
+        if (response.statusCode() != 200) {
+            throw new RuntimeException("API-fel: " + response.statusCode());
+        }
+
+        // Parse JSON
+        JsonNode root = mapper.readTree(response.body());
+        JsonNode results = root.get("results");
+        if (results == null || !results.isArray()) {
+            return List.of();
+        }
+
+        List<ItunesDTO> songs = new ArrayList<>();
+        for (JsonNode node : results) {
+            ItunesDTO song = mapper.treeToValue(node, ItunesDTO.class);
+            songs.add(song);
+        }
+
+        return songs;
+    }
+}
+
diff --git a/src/main/java/org/example/ItunesDTO.java b/src/main/java/org/example/ItunesDTO.java
new file mode 100644
index 00000000..c85e89ac
--- /dev/null
+++ b/src/main/java/org/example/ItunesDTO.java
@@ -0,0 +1,23 @@
+package org.example;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+import java.time.LocalDate;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public record ItunesDTO(Long artistId,
+                        Long collectionId,
+                        Long trackId,
+                        String trackName,
+                        String artistName,
+                        String collectionName,
+                        String country,
+                        String primaryGenreName,
+                        LocalDate releaseDate,
+                        Long trackCount,
+                        Long trackTimeMillis) {
+
+    public int releaseYear() {
+        return releaseDate != null ? releaseDate.getYear() : 0;
+    }
+}
diff --git a/src/main/java/org/example/ItunesPlayList.java b/src/main/java/org/example/ItunesPlayList.java
new file mode 100644
index 00000000..d637f428
--- /dev/null
+++ b/src/main/java/org/example/ItunesPlayList.java
@@ -0,0 +1,345 @@
+package org.example;
+
+import javafx.beans.property.SimpleStringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.collections.transformation.FilteredList;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Scene;
+import javafx.scene.control.*;
+import javafx.scene.layout.*;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.text.Text;
+import javafx.stage.Stage;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Huvudklass för GUI:t. Hanterar visning av bibliotek, spellistor och sökning.
+ */
+public class ItunesPlayList {
+
+    // --- DATAMODELLER ---
+
+    // En Map som lagrar alla spellistor. Nyckeln är namnet (t.ex. "Musik") och värdet är listan med låtar.
+    private Map<String, ObservableList<DisplaySong>> allPlaylists = new HashMap<>();
+
+    // Listan med namn på spellistor som visas i vänstermenyn (Sidebar).
+    // "ObservableList" gör att GUI:t uppdateras automatiskt om vi lägger till/tar bort namn här.
+    private ObservableList<String> playlistNames = FXCollections.observableArrayList();
+
+    // --- GUI KOMPONENTER ---
+
+    // Tabellen i mitten som visar låtarna
+    private TableView<DisplaySong> songTable = new TableView<>();
+
+    // Listan till vänster där man väljer spellista
+    private ListView<String> sourceList = new ListView<>();
+
+    // Textfält för den "digitala displayen" högst upp
+    private Text lcdTitle = new Text("myTunes");
+    private Text lcdArtist = new Text("Välj bibliotek eller spellista");
+
+    /**
+     * Bygger upp hela gränssnittet och visar fönstret.
+     * @param dbSongs En lista med låtar hämtade från databasen/backend.
+     */
+    public void showLibrary(List<org.example.entity.Song> dbSongs) {
+        Stage stage = new Stage();
+
+        // Konvertera databas-objekten till vår interna DisplaySong-klass och skapa grundlistorna
+        initData(dbSongs);
+
+        // BorderPane är huvudlayouten: Top, Left, Center, Bottom
+        BorderPane root = new BorderPane();
+
+        // ---------------------------------------------------------
+        // 1. TOPPEN (Knappar, LCD-display, Sökfält)
+        // ---------------------------------------------------------
+        HBox topPanel = new HBox(15); // HBox lägger saker på rad horisontellt
+        topPanel.getStyleClass().add("top-panel"); // CSS-klass för styling
+        topPanel.setPadding(new Insets(10, 15, 10, 15));
+        topPanel.setAlignment(Pos.CENTER_LEFT);
+
+        // Skapa LCD-displayen (den blå rutan med text)
+        StackPane lcdDisplay = createLCDDisplay();
+        // Säg åt displayen att växa och ta upp ledig plats i bredd
+        HBox.setHgrow(lcdDisplay, Priority.ALWAYS);
+
+        // Sökfältet
+        TextField searchField = new TextField();
+        searchField.setPromptText("Sök...");
+        searchField.getStyleClass().add("itunes-search");
+
+        // Lyssnare: När texten ändras i sökfältet, kör metoden filterSongs()
+        searchField.textProperty().addListener((obs, old, newVal) -> filterSongs(newVal));
+
+        // Lägg till allt i toppen
+        topPanel.getChildren().addAll(
+            createRoundButton("⏮"), createRoundButton("▶"), createRoundButton("⏭"),
+            lcdDisplay, searchField
+        );
+
+        // ---------------------------------------------------------
+        // 2. VÄNSTER (Spellistorna)
+        // ---------------------------------------------------------
+        sourceList.setItems(playlistNames); // Koppla data till listan
+        sourceList.getStyleClass().add("source-list");
+        sourceList.setPrefWidth(200);
+
+        // Lyssnare: Vad händer när man klickar på en spellista i menyn?
+        sourceList.getSelectionModel().selectedItemProperty().addListener((obs, old, newVal) -> {
+            if (newVal != null) {
+                searchField.clear(); // Rensa gammal sökning
+                // Hämta låtlistan från vår Map baserat på namnet och visa i tabellen
+                songTable.setItems(allPlaylists.get(newVal));
+            }
+        });
+        sourceList.getSelectionModel().selectFirst(); // Välj första listan ("Musik") som startvärde
+
+        // ---------------------------------------------------------
+        // 3. MITTEN (Låttabellen)
+        // ---------------------------------------------------------
+        setupTable(); // Konfigurerar kolumner och beteende för tabellen
+
+        // ---------------------------------------------------------
+        // 4. BOTTEN (Knappar för att hantera listor)
+        // ---------------------------------------------------------
+        HBox bottomPanel = new HBox(10);
+        bottomPanel.setPadding(new Insets(10));
+        bottomPanel.getStyleClass().add("bottom-panel");
+
+        Button btnAddList = new Button("+");
+        btnAddList.getStyleClass().add("list-control-button");
+        Button btnDeleteList = new Button("-");
+        btnDeleteList.getStyleClass().add("list-control-button");
+        Button btnMoveToPlaylist = new Button("Lägg till Låt i spellista");
+        Button btnRemoveSong = new Button("Ta bort låt från lista");
+
+        // Koppla knapparna till metoder
+        btnAddList.setOnAction(e -> createNewPlaylist());
+        btnDeleteList.setOnAction(e -> deleteSelectedPlaylist());
+        btnRemoveSong.setOnAction(e -> removeSelectedSong());
+        btnMoveToPlaylist.setOnAction(e -> addSelectedSong(btnMoveToPlaylist));
+
+        bottomPanel.getChildren().addAll(btnAddList, btnDeleteList, new Separator(), btnMoveToPlaylist, btnRemoveSong);
+
+        // ---------------------------------------------------------
+        // SLUTMONTERING
+        // ---------------------------------------------------------
+
+        // SplitPane gör att användaren kan dra i gränsen mellan vänstermeny och tabell
+        SplitPane splitPane = new SplitPane(sourceList, songTable);
+        splitPane.setDividerPositions(0.25); // Sätt startposition för avdelaren
+
+        root.setTop(topPanel);
+        root.setCenter(splitPane);
+        root.setBottom(bottomPanel);
+
+        Scene scene = new Scene(root, 950, 600);
+        // Ladda CSS-filen (måste ligga i resources-mappen)
+        scene.getStylesheets().add(getClass().getResource("/ipod_style.css").toExternalForm());
+
+        stage.setScene(scene);
+        stage.setTitle("myTunes");
+        stage.show();
+    }
+
+    /**
+     * Hjälpmetod för att skapa LCD-displayen (bakgrund + text).
+     */
+    private StackPane createLCDDisplay() {
+        StackPane stack = new StackPane();
+        Rectangle bg = new Rectangle(350, 45);
+        bg.getStyleClass().add("lcd-background");
+
+        VBox textStack = new VBox(2);
+        textStack.setAlignment(Pos.CENTER);
+        lcdTitle.getStyleClass().add("lcd-title");
+        lcdArtist.getStyleClass().add("lcd-artist");
+
+        textStack.getChildren().addAll(lcdTitle, lcdArtist);
+        stack.getChildren().addAll(bg, textStack);
+        return stack;
+    }
+
+    /**
+     * Hjälpmetod för att skapa en standardiserad knapp.
+     */
+    private Button createRoundButton(String icon) {
+        Button b = new Button(icon);
+        b.getStyleClass().add("itunes-button");
+        return b;
+    }
+
+    /**
+     * Konfigurerar kolumnerna i tabellen och hur data ska visas.
+     */
+    private void setupTable() {
+        // Skapa kolumner
+        TableColumn<DisplaySong, String> titleCol = new TableColumn<>("Namn");
+        // Berätta för kolumnen vilket fält i DisplaySong den ska läsa från (name)
+        titleCol.setCellValueFactory(d -> new SimpleStringProperty(d.getValue().name));
+
+        TableColumn<DisplaySong, String> artistCol = new TableColumn<>("Artist");
+        artistCol.setCellValueFactory(d -> new SimpleStringProperty(d.getValue().artist));
+
+        TableColumn<DisplaySong, String> albumCol = new TableColumn<>("Album");
+        albumCol.setCellValueFactory(d -> new SimpleStringProperty(d.getValue().album));
+
+        TableColumn<DisplaySong, String> timeCol = new TableColumn<>("Längd");
+        timeCol.setCellValueFactory(d -> new SimpleStringProperty(d.getValue().time));
+
+        songTable.getColumns().setAll(titleCol, artistCol, albumCol, timeCol);
+        songTable.getStyleClass().add("song-table");
+
+        // Gör så att kolumnerna fyller ut hela bredden
+        songTable.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);
+
+        // Lyssnare: När man klickar på en rad i tabellen -> Uppdatera LCD-displayen
+        songTable.getSelectionModel().selectedItemProperty().addListener((obs, old, newVal) -> {
+            if (newVal != null) {
+                lcdTitle.setText(newVal.name);
+                lcdArtist.setText(newVal.artist);
+            }
+        });
+    }
+
+    /**
+     * Filtrerar låtarna i den aktiva listan baserat på söktexten.
+     */
+    private void filterSongs(String searchText) {
+        String currentList = sourceList.getSelectionModel().getSelectedItem();
+        if (currentList == null) return;
+
+        // Hämta originaldatan för den valda spellistan
+        ObservableList<DisplaySong> masterData = allPlaylists.get(currentList);
+
+        // Om sökfältet är tomt, visa allt
+        if (searchText == null || searchText.isEmpty()) {
+            songTable.setItems(masterData);
+            return;
+        }
+
+        // Skapa en filtrerad lista som omsluter masterData
+        FilteredList<DisplaySong> filteredData = new FilteredList<>(masterData, song -> {
+            String filter = searchText.toLowerCase();
+            // Returnera true om sökordet finns i namn, artist eller album
+            return song.name.toLowerCase().contains(filter) ||
+                song.artist.toLowerCase().contains(filter) ||
+                song.album.toLowerCase().contains(filter);
+        });
+
+        songTable.setItems(filteredData);
+    }
+
+    /**
+     * Omvandlar databas-objekten till GUI-objekt och skapar standardlistor.
+     */
+    private void initData(List<org.example.entity.Song> dbSongs) {
+        ObservableList<DisplaySong> library = FXCollections.observableArrayList();
+
+        // Loopa igenom datan från databasen
+        if (dbSongs != null) {
+            for (org.example.entity.Song s : dbSongs) {
+                // Hantera null-värden snyggt (om artist eller album saknas)
+                String art = (s.getAlbum() != null && s.getAlbum().getArtist() != null) ? s.getAlbum().getArtist().getName() : "Okänd";
+                String alb = (s.getAlbum() != null) ? s.getAlbum().getName() : "Okänt";
+
+                // Skapa ett nytt DisplaySong-objekt
+                library.add(new DisplaySong(s.getTitle(), art, alb, s.getLength()));
+            }
+        }
+
+        // Lägg in huvudbiblioteket "Musik"
+        allPlaylists.put("Musik", library);
+        playlistNames.add("Musik");
+
+        // Skapa en tom lista för "Favoriter"
+        allPlaylists.put("Favoriter", FXCollections.observableArrayList());
+        playlistNames.add("Favoriter");
+    }
+
+    /**
+     * Visar en dialogruta för att skapa en ny spellista.
+     */
+    private void createNewPlaylist() {
+        TextInputDialog d = new TextInputDialog("Ny lista");
+
+        // Här ändrar du fönstrets titel och text
+        d.setTitle("Skapa ny spellista");        // Ersätter "Bekräftelse"
+        d.setHeaderText("Ange namn på din nya lista"); // Rubriken inuti rutan
+        d.setContentText("Namn:");               // Texten bredvid inmatningsfältet
+
+        d.showAndWait().ifPresent(name -> {
+            // Kontrollera att namnet inte är tomt och inte redan finns
+            if (!name.trim().isEmpty() && !allPlaylists.containsKey(name)) {
+                allPlaylists.put(name, FXCollections.observableArrayList());
+                playlistNames.add(name);
+            }
+        });
+    }
+
+    /**
+     * Tar bort vald spellista (men tillåter inte att man tar bort "Musik").
+     */
+    private void deleteSelectedPlaylist() {
+        String sel = sourceList.getSelectionModel().getSelectedItem();
+        if (sel != null && !sel.equals("Musik")) {
+            allPlaylists.remove(sel);
+            playlistNames.remove(sel);
+        }
+    }
+
+    /**
+     * Tar bort vald låt från den aktiva spellistan (ej från huvudbiblioteket "Musik").
+     */
+    private void removeSelectedSong() {
+        DisplaySong sel = songTable.getSelectionModel().getSelectedItem();
+        String list = sourceList.getSelectionModel().getSelectedItem();
+        // Skydd: Man får inte ta bort låtar direkt från "Musik"-biblioteket i denna vy
+        if (sel != null && list != null && !list.equals("Musik")) {
+            allPlaylists.get(list).remove(sel);
+        }
+    }
+
+    /**
+     * Visar en popup-meny för att lägga till vald låt i en annan spellista.
+     */
+    private void addSelectedSong(Button anchor) {
+        DisplaySong sel = songTable.getSelectionModel().getSelectedItem();
+        if (sel == null) return; // Ingen låt vald
+
+        ContextMenu menu = new ContextMenu();
+        for (String n : playlistNames) {
+            if (n.equals("Musik")) continue; // Man kan inte lägga till i "Musik" (det är källan)
+
+            MenuItem itm = new MenuItem(n);
+            itm.setOnAction(e -> {
+                // Om låten inte redan finns i listan, lägg till den
+                if (!allPlaylists.get(n).contains(sel)) {
+                    allPlaylists.get(n).add(sel);
+                }
+            });
+            menu.getItems().add(itm);
+        }
+        // Visa menyn vid knappen
+        menu.show(anchor, anchor.getScene().getWindow().getX() + anchor.getLayoutX(), anchor.getScene().getWindow().getY() + anchor.getLayoutY());
+    }
+
+    /**
+     * En inre klass (DTO - Data Transfer Object) enbart för visning i tabellen.
+     * Detta skiljer GUI-logiken från databas-entiteterna.
+     */
+    public static class DisplaySong {
+        String name, artist, album, time;
+        public DisplaySong(String n, String a, String al, Long t) {
+            this.name = n;
+            this.artist = a;
+            this.album = al;
+            this.time = String.valueOf(t);
+        }
+    }
+}
diff --git a/src/main/java/org/example/MyPod.java b/src/main/java/org/example/MyPod.java
new file mode 100644
index 00000000..5500942e
--- /dev/null
+++ b/src/main/java/org/example/MyPod.java
@@ -0,0 +1,374 @@
+package org.example;
+
+import jakarta.persistence.EntityManagerFactory;
+import javafx.concurrent.Task;
+import javafx.application.Platform;
+import javafx.application.Application;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Scene;
+import javafx.scene.control.Label;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.input.KeyCode;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Rectangle;
+import javafx.stage.Stage;
+import org.example.entity.Album;
+import org.example.entity.Artist;
+import org.example.entity.Song;
+import org.example.repo.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Huvudklassen för applikationen "MyPod".
+ * Denna klass bygger upp GUI:t (simulerar en iPod) och hanterar navigering.
+ */
+public class MyPod extends Application {
+
+    // --- DATA-LAGER ---
+    // Repositories används för att hämta data från databasen istället för att hårdkoda den.
+    private final SongRepository songRepo = new SongRepositoryImpl();
+    private final ArtistRepository artistRepo = new ArtistRepositoryImpl();
+    private final AlbumRepository albumRepo = new AlbumRepositoryImpl();
+    private final ItunesApiClient apiClient = new ItunesApiClient();
+
+    // Listor som håller datan vi hämtat från databasen
+    private List<Song> songs;
+    private List<Artist> artists;
+    private List<Album> albums;
+
+    // --- MENY-DATA ---
+    // Huvudmenyns alternativ. "ObservableList" är en speciell lista i JavaFX
+    // som GUI:t kan "lyssna" på, även om vi här mest använder den som en vanlig lista.
+    private final ObservableList<String> mainMenu = FXCollections.observableArrayList(
+        "Songs", "Artists", "Albums", "Playlists");
+
+    // En lista med själva Label-objekten som visas på skärmen (för att kunna markera/avmarkera dem)
+    private final List<Label> menuLabels = new ArrayList<>();
+
+    // --- GUI-TILLSTÅND ---
+    private int selectedIndex = 0;      // Håller koll på vilket menyval som är markerat just nu
+    private VBox screenContent;         // Behållaren för texten/listan inuti "skärmen"
+    private StackPane myPodScreen;       // Själva skärm-containern
+    private ScrollPane scrollPane;      // Gör att vi kan scrolla om listan är lång
+    private boolean isMainMenu = true;  // Flagga för att veta om vi är i huvudmenyn eller en undermeny
+
+    @Override
+    public void start(Stage primaryStage) {
+        // --- LAYOUT SETUP ---
+        // BorderPane är bra för att placera saker i Top, Bottom, Center, Left, Right.
+        BorderPane root = new BorderPane();
+        root.setPadding(new Insets(20)); // Lite luft runt kanten
+        root.getStyleClass().add("ipod-body"); // CSS-klass för själva iPod-kroppen
+
+        // 1. Skapa och placera skärmen högst upp
+        myPodScreen = createMyPodScreen();
+        root.setTop(myPodScreen);
+
+        // 2. Skapa och placera klickhjulet längst ner
+        StackPane clickWheel = createClickWheel();
+        root.setBottom(clickWheel);
+        BorderPane.setMargin(clickWheel, new Insets(30, 0, 0, 0)); // Marginal ovanför hjulet
+
+        // --- BAKGRUNDSLADDNING ---
+        // Vi använder en Task för att ladda databasen. Detta är kritiskt!
+        // Om vi laddar databasen direkt i start() fryser hela fönstret tills det är klart.
+        Task<Void> initTask = new Task<>() {
+            @Override
+            protected Void call() {
+                initializeData(); // Detta tunga jobb körs i en separat tråd
+                return null;
+            }
+        };
+
+        // När datan är laddad och klar:
+        initTask.setOnSucceeded(e -> {
+            if (isMainMenu) showMainMenu(); // Rita upp menyn nu när vi har data
+        });
+
+        // Om något går fel (t.ex. ingen databasanslutning):
+        initTask.setOnFailed(e -> {
+            // Platform.runLater måste användas när vi ändrar GUI:t från en annan tråd
+            Platform.runLater(() -> {
+                Label error = new Label("Failed to load data.");
+                error.setStyle("-fx-text-fill: red;");
+                screenContent.getChildren().add(error);
+            });
+        });
+
+        // Starta laddningstråden
+        new Thread(initTask).start();
+
+        // --- SCEN OCH CSS ---
+        Scene scene = new Scene(root, 300, 500);
+        try {
+            // Försök ladda CSS-filen för styling
+            scene.getStylesheets().add(getClass().getResource("/ipod_style.css").toExternalForm());
+        } catch (Exception e) {
+            System.out.println("CSS hittades inte, kör utan styling.");
+        }
+
+        // Koppla tangentbordslyssnare för att kunna styra menyn
+        setupNavigation(scene);
+        showMainMenu(); // Initiera första vyn (tom tills datan laddats klart)
+
+        primaryStage.setTitle("myPod");
+        primaryStage.setScene(scene);
+        primaryStage.setResizable(false);
+        primaryStage.show();
+    }
+
+    /**
+     * Skapar den visuella skärmen (den "lysande" rutan).
+     */
+    private StackPane createMyPodScreen() {
+        StackPane screenContainer = new StackPane();
+        screenContainer.getStyleClass().add("ipod-screen");
+
+        double width = 260;
+        double height = 180;
+        screenContainer.setPrefSize(width, height);
+        screenContainer.setMaxSize(width, height);
+
+        // Skapa en "mask" (Rectangle) för att klippa innehållet så hörnen blir rundade
+        Rectangle clip = new Rectangle(width, height);
+        clip.setArcWidth(15);
+        clip.setArcHeight(15);
+        screenContainer.setClip(clip);
+
+        scrollPane = new ScrollPane();
+        screenContent = new VBox(2); // VBox staplar element vertikalt. 2px mellanrum.
+        screenContent.setAlignment(Pos.TOP_LEFT);
+        screenContent.setPadding(new Insets(10, 5, 10, 5));
+
+        // Konfigurera scrollbaren så den inte syns men fungerar
+        scrollPane.setContent(screenContent);
+        scrollPane.setHbarPolicy(ScrollPane.ScrollBarPolicy.NEVER); // Ingen horisontell scroll
+        scrollPane.setVbarPolicy(ScrollPane.ScrollBarPolicy.NEVER); // Ingen synlig vertikal scroll
+        scrollPane.setFitToWidth(true); // Innehållet ska fylla bredden
+        scrollPane.setStyle("-fx-background: transparent; -fx-background-color: transparent;");
+
+        screenContainer.getChildren().add(scrollPane);
+        return screenContainer;
+    }
+
+    /**
+     * Skapar klickhjulet med knappar.
+     */
+    private StackPane createClickWheel() {
+        StackPane wheel = new StackPane();
+        wheel.setPrefSize(200, 200);
+
+        // Det stora yttre hjulet
+        Circle outerWheel = new Circle(100);
+        outerWheel.getStyleClass().add("outer-wheel");
+
+        // Den lilla knappen i mitten
+        Circle centerButton = new Circle(30);
+        centerButton.getStyleClass().add("center-button");
+
+        // Etiketter för knapparna (MENU, Play, Fram, Bak)
+        Label menu = new Label("MENU");
+        menu.getStyleClass().add("wheel-text-menu");
+        // Om man klickar på ordet MENU med musen går man tillbaka
+        menu.setOnMouseClicked(e -> showMainMenu());
+
+        Label ff = new Label("⏭"); ff.getStyleClass().add("wheel-text"); ff.setId("ff-button");
+        Label rew = new Label("⏮"); rew.getStyleClass().add("wheel-text"); rew.setId("rew-button");
+        Label play = new Label("▶"); play.getStyleClass().add("wheel-text-play");
+
+        wheel.getChildren().addAll(outerWheel, centerButton, menu, ff, rew, play);
+        return wheel;
+    }
+
+    /**
+     * Hanterar tangentbordsnavigering (Upp, Ner, Enter, Escape).
+     */
+    private void setupNavigation(Scene scene) {
+        scene.setOnKeyPressed(event -> {
+            // ESCAPE fungerar som "Back"-knapp
+            if (event.getCode() == KeyCode.ESCAPE) {
+                showMainMenu();
+                return;
+            }
+
+            int totalItems = menuLabels.size();
+            if (totalItems == 0) return; // Gör inget om listan är tom
+
+            int newIndex = selectedIndex;
+
+            // Navigera NER
+            if (event.getCode() == KeyCode.DOWN) {
+                // Modulo (%) gör att om vi trycker ner på sista elementet, hamnar vi på 0 igen.
+                newIndex = (selectedIndex + 1) % totalItems;
+            }
+            // Navigera UPP
+            else if (event.getCode() == KeyCode.UP) {
+                // Matematisk formel för att loopa bakåt (från 0 till sista)
+                newIndex = (selectedIndex - 1 + totalItems) % totalItems;
+            }
+            // Välj (ENTER)
+            else if (event.getCode() == KeyCode.ENTER) {
+                if (isMainMenu) {
+                    // Om vi är i huvudmenyn, gå in i en undermeny (t.ex. "Songs")
+                    showScreen(mainMenu.get(selectedIndex));
+                } else {
+                    // Om vi är i en lista, hantera valet (spela låt etc)
+                    handleSelection(menuLabels.get(selectedIndex).getText());
+                }
+                return;
+            }
+
+            // Om indexet ändrades, uppdatera grafiken
+            if (newIndex != selectedIndex) {
+                selectedIndex = newIndex;
+                updateMenu();
+            }
+        });
+    }
+
+    /**
+     * Uppdaterar visuellt vilken rad som är vald (lägger till CSS-klass).
+     */
+    private void updateMenu() {
+        for (int i = 0; i < menuLabels.size(); i++) {
+            Label label = menuLabels.get(i);
+            if (i == selectedIndex) {
+                label.getStyleClass().add("selected-item"); // Gör texten markerad
+                ensureVisible(label); // Se till att scrollbaren flyttas så vi ser valet
+            } else {
+                label.getStyleClass().remove("selected-item"); // Ta bort markering
+            }
+        }
+    }
+
+    /**
+     * Avancerad metod för att automatiskt scrolla ScrollPane till det markerade elementet.
+     */
+    private void ensureVisible(Label node) {
+        Platform.runLater(() -> {
+            double contentHeight = screenContent.getBoundsInLocal().getHeight();
+            double viewportHeight = scrollPane.getViewportBounds().getHeight();
+            double nodeY = node.getBoundsInParent().getMinY();
+
+            // Om innehållet är högre än skärmen, räkna ut var vi ska scrolla
+            if (contentHeight > viewportHeight) {
+                // Beräkna positionen (0.0 är toppen, 1.0 är botten)
+                double scrollTarget = nodeY / (contentHeight - viewportHeight);
+                // Sätt värdet men tvinga det att vara mellan 0 och 1
+                scrollPane.setVvalue(Math.min(1.0, Math.max(0.0, scrollTarget)));
+            }
+        });
+    }
+
+    /**
+     * Visar en undermeny (Songs, Artists etc).
+     */
+    private void showScreen(String screenName) {
+        screenContent.getChildren().clear(); // Rensa skärmen
+        menuLabels.clear();                  // Rensa listan med menyval
+        isMainMenu = false;                  // Vi är inte i huvudmenyn längre
+        selectedIndex = 0;                   // Återställ markör till toppen
+
+        // Rubrik
+        Label screenTitle = new Label(screenName);
+        screenTitle.getStyleClass().add("screen-title");
+        screenContent.getChildren().add(screenTitle);
+
+        // Fyll på med rätt data beroende på vad användaren valde
+        switch (screenName) {
+            case "Songs" -> {
+                if (songs != null && !songs.isEmpty()) {
+                    songs.forEach(s -> addMenuItem(s.getTitle()));
+                } else addMenuItem("No songs found");
+            }
+            case "Artists" -> {
+                if (artists != null && !artists.isEmpty()) {
+                    artists.forEach(a -> addMenuItem(a.getName()));
+                } else addMenuItem("No artists found");
+            }
+            case "Albums" -> {
+                if (albums != null && !albums.isEmpty()) {
+                    albums.forEach(al -> addMenuItem(al.getName()));
+                } else addMenuItem("No albums found");
+            }
+            case "Playlists" -> {
+                openMusicPlayer(); // Öppnar myTunes i nytt fönster
+                return;
+            }
+        }
+        updateMenu(); // Uppdatera så första valet är markerat
+    }
+
+    /**
+     * Hjälpmetod för att lägga till en rad i listan på skärmen.
+     */
+    private void addMenuItem(String text) {
+        Label label = new Label(text);
+        label.getStyleClass().add("menu-item");
+        label.setMaxWidth(Double.MAX_VALUE); // Gör att raden fyller hela bredden (snyggare markering)
+        menuLabels.add(label);
+        screenContent.getChildren().add(label);
+    }
+
+    /**
+     * Visar huvudmenyn igen.
+     */
+    private void showMainMenu() {
+        screenContent.getChildren().clear();
+        menuLabels.clear();
+        isMainMenu = true;
+        selectedIndex = 0;
+
+        Label title = new Label("myPod");
+        title.getStyleClass().add("screen-title");
+        screenContent.getChildren().add(title);
+
+        for (String item : mainMenu) {
+            addMenuItem(item);
+        }
+        updateMenu();
+    }
+
+    /**
+     * Vad som händer när man trycker Enter på en låt/artist.
+     */
+    private void handleSelection(String selection) {
+        // Här kan du lägga till logik för att spela låten eller öppna albumet
+        System.out.println("User selected: " + selection);
+    }
+
+    /**
+     * Öppnar det externa fönstret "ItunesPlayList".
+     */
+    private void openMusicPlayer() {
+        ItunesPlayList itunesPlayList = new ItunesPlayList();
+        itunesPlayList.showLibrary(this.songs);
+    }
+
+    /**
+     * Initierar databasen och hämtar all data.
+     * OBS: Denna körs i en bakgrundstråd (via Task i start-metoden).
+     */
+    private void initializeData() {
+        try {
+            EntityManagerFactory emf = PersistenceManager.getEntityManagerFactory();
+            DatabaseInitializer initializer = new DatabaseInitializer(apiClient, songRepo, albumRepo, artistRepo);
+            initializer.init(); // Fyll databasen om den är tom
+
+            // Hämta data till minnet
+            this.songs = songRepo.findAll();
+            this.artists = artistRepo.findAll();
+            this.albums = albumRepo.findAll();
+        } catch (Exception e) {
+            System.err.println("Kunde inte ladda data: " + e.getMessage());
+        }
+    }
+}
diff --git a/src/main/java/org/example/PersistenceManager.java b/src/main/java/org/example/PersistenceManager.java
new file mode 100644
index 00000000..817c23dd
--- /dev/null
+++ b/src/main/java/org/example/PersistenceManager.java
@@ -0,0 +1,54 @@
+package org.example;
+
+import io.github.classgraph.ClassGraph;
+import io.github.classgraph.ScanResult;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EntityManagerFactory;
+import jakarta.persistence.PersistenceConfiguration;
+import org.hibernate.jpa.HibernatePersistenceConfiguration;
+
+import java.util.List;
+
+public class PersistenceManager {
+
+    private static final EntityManagerFactory emf;
+
+    static {
+
+        List<Class<?>> entities = getEntities("org.example.entity");
+
+        final PersistenceConfiguration cfg = new HibernatePersistenceConfiguration("emf")
+            .jdbcUrl("jdbc:mysql://localhost:3306/myPodDB")
+            .jdbcUsername("user")
+            .jdbcPassword("pass")
+            .property("hibernate.hbm2ddl.auto", "update")
+            .property("hibernate.show_sql", "true")
+            .property("hibernate.format_sql", "true")
+            .property("hibernate.highlight_sql", "true")
+            .managedClasses(entities);
+
+        emf = cfg.createEntityManagerFactory();
+
+        //From CodeRabbit: Register a shutdown hook to properly release database connections on JVM exit.
+        Runtime.getRuntime().addShutdownHook(new Thread(emf::close));
+
+    }
+
+    public static EntityManagerFactory getEntityManagerFactory() {
+        return emf;
+    }
+
+    //Not invented here!!
+    private static List<Class<?>> getEntities(String pkg) {
+        List<Class<?>> entities;
+        try (ScanResult scanResult =
+                 new ClassGraph()
+                     .enableClassInfo()
+                     .enableAnnotationInfo()
+                     .acceptPackages(pkg)
+                     .scan()) {
+            entities = scanResult.getClassesWithAnnotation(Entity.class).loadClasses();
+        }
+        return entities;
+    }
+}
diff --git a/src/main/java/org/example/entity/Album.java b/src/main/java/org/example/entity/Album.java
new file mode 100644
index 00000000..1de7efeb
--- /dev/null
+++ b/src/main/java/org/example/entity/Album.java
@@ -0,0 +1,130 @@
+package org.example.entity;
+
+import jakarta.persistence.*;
+import org.example.ItunesDTO;
+import org.hibernate.proxy.HibernateProxy;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+@Entity
+public class Album {
+
+    @Id
+    @Column(name="album_id")
+    private Long albumId;
+
+    private String name;
+
+    private String genre;
+
+    private int year;
+
+    private Long trackCount;
+
+//    @OneToMany(mappedBy = "album")
+    //private List<Song> song;
+
+   // @ManyToOne(cascade = CascadeType.PERSIST)
+   // @JoinColumn(name="artist_id")
+ //   private Artist artist;
+
+    @ManyToOne
+    @JoinColumn(name = "artist_id")
+    private Artist artist;
+
+    @OneToMany(mappedBy = "album", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<Song> song = new ArrayList<>();
+
+    protected Album (){}
+
+    public Album(Long albumId, String name, String genre, int year, Long trackCount, Artist artist) {
+        this.albumId = albumId;
+        this.name = name;
+        this.genre = genre;
+        this.year = year;
+        this.trackCount = trackCount;
+        this.artist = artist;
+    }
+
+    public static Album fromDTO(ItunesDTO dto, Artist artist) {
+        if (dto.collectionId() == null || dto.collectionName() == null){
+            throw new IllegalArgumentException("Required fields (albumId, albumName) cannot be null");
+        }
+        return new Album(dto.collectionId(), dto.collectionName(), dto.primaryGenreName(), dto.releaseYear(), dto.trackCount(),artist);
+    }
+
+    public Long getAlbumId() {
+        return albumId;
+    }
+
+    public void setAlbumId(Long albumId) {
+        this.albumId = albumId;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getGenre() {
+        return genre;
+    }
+
+    public void setGenre(String genre) {
+        this.genre = genre;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+
+    public Long getTrackCount() {
+        return trackCount;
+    }
+
+    public void setTrackCount(Long trackCount) {
+        this.trackCount = trackCount;
+    }
+
+    public List<Song> getSong() {
+        return song;
+    }
+
+    public void setSong(List<Song> song) {
+        this.song = song;
+    }
+
+    public Artist getArtist() {
+        return artist;
+    }
+
+    public void setArtist(Artist artist) {
+        this.artist = artist;
+    }
+
+    @Override
+    public final boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null) return false;
+        Class<?> oEffectiveClass = o instanceof HibernateProxy ? ((HibernateProxy) o).getHibernateLazyInitializer().getPersistentClass() : o.getClass();
+        Class<?> thisEffectiveClass = this instanceof HibernateProxy ? ((HibernateProxy) this).getHibernateLazyInitializer().getPersistentClass() : this.getClass();
+        if (thisEffectiveClass != oEffectiveClass) return false;
+        Album album = (Album) o;
+        return getAlbumId() != null && Objects.equals(getAlbumId(), album.getAlbumId());
+    }
+
+    @Override
+    public final int hashCode() {
+        return this instanceof HibernateProxy ? ((HibernateProxy) this).getHibernateLazyInitializer().getPersistentClass().hashCode() : getClass().hashCode();
+    }
+}
diff --git a/src/main/java/org/example/entity/Artist.java b/src/main/java/org/example/entity/Artist.java
new file mode 100644
index 00000000..0576f63c
--- /dev/null
+++ b/src/main/java/org/example/entity/Artist.java
@@ -0,0 +1,88 @@
+package org.example.entity;
+
+import jakarta.persistence.*;
+import org.example.ItunesDTO;
+import org.hibernate.proxy.HibernateProxy;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+@Entity
+public class Artist {
+
+    @Id
+    @Column(name = "artist_id")
+    private Long artistId;
+
+    private String name;
+
+    private String country;
+        
+    @OneToMany(mappedBy = "artist", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<Album> album = new ArrayList<>();
+
+    protected Artist() {
+    }
+
+    public Artist(Long artistId, String name, String country) {
+        this.artistId = artistId;
+        this.name = name;
+        this.country = country;
+    }
+
+    public static Artist fromDTO(ItunesDTO dto) {
+        if (dto.artistId() == null || dto.artistName() == null) {
+            throw new IllegalArgumentException("Required fields (artistId, artistName) cannot be null");
+        }
+        return new Artist(dto.artistId(), dto.artistName(), dto.country());
+    }
+
+    public Long getArtistId() {
+        return artistId;
+    }
+
+    public void setArtistId(Long artistId) {
+        this.artistId = artistId;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getCountry() {
+        return country;
+    }
+
+    public void setCountry(String country) {
+        this.country = country;
+    }
+
+    public List<Album> getAlbum() {
+        return album;
+    }
+
+    public void setAlbum(List<Album> album) {
+        this.album = album;
+    }
+
+    @Override
+    public final boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null) return false;
+        Class<?> oEffectiveClass = o instanceof HibernateProxy ? ((HibernateProxy) o).getHibernateLazyInitializer().getPersistentClass() : o.getClass();
+        Class<?> thisEffectiveClass = this instanceof HibernateProxy ? ((HibernateProxy) this).getHibernateLazyInitializer().getPersistentClass() : this.getClass();
+        if (thisEffectiveClass != oEffectiveClass) return false;
+        Artist artist = (Artist) o;
+        return getArtistId() != null && Objects.equals(getArtistId(), artist.getArtistId());
+    }
+
+    @Override
+    public final int hashCode() {
+        return this instanceof HibernateProxy ? ((HibernateProxy) this).getHibernateLazyInitializer().getPersistentClass().hashCode() : getClass().hashCode();
+    }
+}
diff --git a/src/main/java/org/example/entity/Playlist.java b/src/main/java/org/example/entity/Playlist.java
new file mode 100644
index 00000000..98c5e304
--- /dev/null
+++ b/src/main/java/org/example/entity/Playlist.java
@@ -0,0 +1,61 @@
+package org.example.entity;
+
+import jakarta.persistence.*;
+import org.hibernate.proxy.HibernateProxy;
+
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+
+@Entity
+public class Playlist {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long playlistId;
+
+    private String name;
+
+    @ManyToMany(cascade = CascadeType.PERSIST)
+    private Set<Song> songs = new HashSet<>();
+
+    public void addSong(Song song) {
+        this.songs.add(song);
+    }
+
+    public void removeSong(Song song) {
+        this.songs.remove(song);
+    }
+
+    public Long getPlaylistId() {
+        return playlistId;
+    }
+
+    public void setPlaylistId(Long playlistId) {
+        this.playlistId = playlistId;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public final boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null) return false;
+        Class<?> oEffectiveClass = o instanceof HibernateProxy ? ((HibernateProxy) o).getHibernateLazyInitializer().getPersistentClass() : o.getClass();
+        Class<?> thisEffectiveClass = this instanceof HibernateProxy ? ((HibernateProxy) this).getHibernateLazyInitializer().getPersistentClass() : this.getClass();
+        if (thisEffectiveClass != oEffectiveClass) return false;
+        Playlist playlist = (Playlist) o;
+        return getPlaylistId() != null && Objects.equals(getPlaylistId(), playlist.getPlaylistId());
+    }
+
+    @Override
+    public final int hashCode() {
+        return this instanceof HibernateProxy ? ((HibernateProxy) this).getHibernateLazyInitializer().getPersistentClass().hashCode() : getClass().hashCode();
+    }
+}
diff --git a/src/main/java/org/example/entity/Song.java b/src/main/java/org/example/entity/Song.java
new file mode 100644
index 00000000..5e2e21cb
--- /dev/null
+++ b/src/main/java/org/example/entity/Song.java
@@ -0,0 +1,111 @@
+package org.example.entity;
+
+import jakarta.persistence.*;
+import org.example.ItunesDTO;
+import org.hibernate.proxy.HibernateProxy;
+
+import java.time.LocalDate;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+
+@Entity
+public class Song {
+
+    @Id
+    @Column(name = "song_id")
+    private Long songId;
+
+    private String title;
+
+    private Long length;
+
+    @ManyToOne
+    @JoinColumn(name = "album_id")
+    private Album album;
+
+    @ManyToMany(mappedBy = "songs")
+    private Set<Playlist> playlist = new HashSet<>();
+
+    protected Song() {
+    }
+
+    public Song(Long songId, String title, Long length, Album album) {
+        this.songId = songId;
+        this.title = title;
+        this.length = length;
+        this.album = album;
+    }
+
+    public static Song fromDTO(ItunesDTO dto, Album album) {
+        if (dto.trackId() == null || dto.trackName() == null) {
+            throw new IllegalArgumentException("Required fields (trackId, trackName) cannot be null");
+        }
+        return new Song(dto.trackId(), dto.trackName(), dto.trackTimeMillis(), album);
+    }
+
+    public Set<Playlist> getPlaylist() {
+        return playlist;
+    }
+
+    public void setPlaylist(Set<Playlist> playlist) {
+        this.playlist = playlist;
+    }
+
+    public Long getSongId() {
+        return songId;
+    }
+
+    public void setSongId(Long id) {
+        this.songId = id;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public Long getLength() {
+        return length;
+    }
+
+    public void setLength(Long length) {
+        this.length = length;
+    }
+
+
+    public Album getAlbum() {
+        return album;
+    }
+
+    public void setAlbum(Album album) {
+        this.album = album;
+    }
+
+    @Override
+    public final boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null) return false;
+        Class<?> oEffectiveClass = o instanceof HibernateProxy ? ((HibernateProxy) o).getHibernateLazyInitializer().getPersistentClass() : o.getClass();
+        Class<?> thisEffectiveClass = this instanceof HibernateProxy ? ((HibernateProxy) this).getHibernateLazyInitializer().getPersistentClass() : this.getClass();
+        if (thisEffectiveClass != oEffectiveClass) return false;
+        Song song = (Song) o;
+        return getSongId() != null && Objects.equals(getSongId(), song.getSongId());
+    }
+
+    @Override
+    public final int hashCode() {
+        return this instanceof HibernateProxy ? ((HibernateProxy) this).getHibernateLazyInitializer().getPersistentClass().hashCode() : getClass().hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + "(" +
+            "songId = " + songId + ", " +
+            "title = " + title + ", " +
+            "length = " + length + ")";
+    }
+}
diff --git a/src/main/java/org/example/repo/AlbumRepository.java b/src/main/java/org/example/repo/AlbumRepository.java
new file mode 100644
index 00000000..7130c18f
--- /dev/null
+++ b/src/main/java/org/example/repo/AlbumRepository.java
@@ -0,0 +1,21 @@
+package org.example.repo;
+
+import org.example.entity.Album;
+import org.example.entity.Artist;
+
+import java.util.List;
+
+public interface AlbumRepository {
+
+    boolean existsByUniqueId(Album album);
+
+    void save(Album album);
+
+    List<Album> findAll();
+
+    List<Album> findByArtist(Artist artist);
+
+    List<Album> findByGenre(String genre);
+
+    Long count();
+}
diff --git a/src/main/java/org/example/repo/AlbumRepositoryImpl.java b/src/main/java/org/example/repo/AlbumRepositoryImpl.java
new file mode 100644
index 00000000..fd1f4f16
--- /dev/null
+++ b/src/main/java/org/example/repo/AlbumRepositoryImpl.java
@@ -0,0 +1,59 @@
+package org.example.repo;
+
+import jakarta.persistence.EntityManagerFactory;
+import org.example.PersistenceManager;
+import org.example.entity.Album;
+import org.example.entity.Artist;
+
+import java.util.List;
+
+public class AlbumRepositoryImpl implements AlbumRepository {
+
+    private final EntityManagerFactory emf = PersistenceManager.getEntityManagerFactory();
+
+    @Override
+    public boolean existsByUniqueId(Album album) {
+        return emf.callInTransaction(em ->
+            em.createQuery("select count(a) from Album a where a.albumId = :albumId", Long.class)
+                .setParameter("albumId", album.getAlbumId())
+                .getSingleResult() > 0
+        );
+    }
+
+    @Override
+    public void save(Album album) {
+        emf.runInTransaction(em -> em.persist(album));
+    }
+
+    @Override
+    public List<Album> findAll() {
+        return emf.callInTransaction(em ->
+            em.createQuery("select a from Album a", Album.class)
+                .getResultList());
+    }
+
+    @Override
+    public List<Album> findByArtist(Artist artist) {
+        return emf.callInTransaction(em ->
+            em.createQuery("select a from Album a where a.artist = :artist", Album.class)
+                .setParameter("artist", artist)
+                .getResultList()
+        );
+    }
+
+    @Override
+    public List<Album> findByGenre(String genre) {
+        return emf.callInTransaction(em ->
+            em.createQuery("select a from Album a where a.genre = :genre", Album.class)
+                .setParameter("genre", genre)
+                .getResultList()
+        );
+    }
+
+    @Override
+    public Long count() {
+        return emf.callInTransaction(em ->
+            em.createQuery("select count(a) from Album a", Long.class)
+                .getSingleResult());
+    }
+}
diff --git a/src/main/java/org/example/repo/ArtistRepository.java b/src/main/java/org/example/repo/ArtistRepository.java
new file mode 100644
index 00000000..8c2ff72d
--- /dev/null
+++ b/src/main/java/org/example/repo/ArtistRepository.java
@@ -0,0 +1,17 @@
+package org.example.repo;
+
+import org.example.entity.Artist;
+
+import java.util.List;
+
+public interface ArtistRepository {
+
+    boolean existsByUniqueId(Artist artist);
+
+    void save(Artist artist);
+
+    List<Artist> findAll();
+
+    Long count();
+
+}
diff --git a/src/main/java/org/example/repo/ArtistRepositoryImpl.java b/src/main/java/org/example/repo/ArtistRepositoryImpl.java
new file mode 100644
index 00000000..2ab2047b
--- /dev/null
+++ b/src/main/java/org/example/repo/ArtistRepositoryImpl.java
@@ -0,0 +1,42 @@
+package org.example.repo;
+
+import jakarta.persistence.EntityManagerFactory;
+import org.example.PersistenceManager;
+import org.example.entity.Album;
+import org.example.entity.Artist;
+import org.example.entity.Song;
+
+import java.util.List;
+
+public class ArtistRepositoryImpl implements ArtistRepository {
+
+    private final EntityManagerFactory emf = PersistenceManager.getEntityManagerFactory();
+
+    @Override
+    public boolean existsByUniqueId(Artist artist) {
+        return emf.callInTransaction(em ->
+            em.createQuery("select count(a) from Artist a where a.artistId = :artistId", Long.class)
+                .setParameter("artistId", artist.getArtistId())
+                .getSingleResult() > 0
+        );
+    }
+
+    @Override
+    public void save(Artist artist) {
+        emf.runInTransaction(em -> em.persist(artist));
+    }
+
+    @Override
+    public List<Artist> findAll() {
+        return emf.callInTransaction(em ->
+            em.createQuery("select a from Artist a", Artist.class)
+                .getResultList());
+    }
+
+    @Override
+    public Long count() {
+        return emf.callInTransaction(em ->
+            em.createQuery("select count(a) from Artist a", Long.class)
+                .getSingleResult());
+    }
+}
diff --git a/src/main/java/org/example/repo/PlaylistRepository.java b/src/main/java/org/example/repo/PlaylistRepository.java
new file mode 100644
index 00000000..61512ca3
--- /dev/null
+++ b/src/main/java/org/example/repo/PlaylistRepository.java
@@ -0,0 +1,23 @@
+package org.example.repo;
+
+import org.example.entity.Playlist;
+import org.example.entity.Song;
+
+import java.util.List;
+
+public interface PlaylistRepository {
+
+    List<Playlist> findAll();
+
+    List<Song> findSongsInPlaylist(Playlist playlist);
+
+    void createPlaylist(String name);
+
+    void deletePlaylist(Playlist playlist);
+
+    void addSong(Playlist playlist, Song song);
+
+    void removeSong(Playlist playlist, Song song);
+
+    void renamePlaylist(Playlist playlist, String newName);
+}
diff --git a/src/main/java/org/example/repo/PlaylistRepositoryImpl.java b/src/main/java/org/example/repo/PlaylistRepositoryImpl.java
new file mode 100644
index 00000000..abd4cb62
--- /dev/null
+++ b/src/main/java/org/example/repo/PlaylistRepositoryImpl.java
@@ -0,0 +1,44 @@
+package org.example.repo;
+
+import org.example.entity.Playlist;
+import org.example.entity.Song;
+
+import java.util.List;
+
+public class PlaylistRepositoryImpl implements PlaylistRepository {
+
+    @Override
+    public List<Playlist> findAll() {
+        return List.of();
+    }
+
+    @Override
+    public List<Song> findSongsInPlaylist(Playlist playlist) {
+        return List.of();
+    }
+
+    @Override
+    public void createPlaylist(String name) {
+
+    }
+
+    @Override
+    public void deletePlaylist(Playlist playlist) {
+
+    }
+
+    @Override
+    public void addSong(Playlist playlist, Song song) {
+
+    }
+
+    @Override
+    public void removeSong(Playlist playlist, Song song) {
+
+    }
+
+    @Override
+    public void renamePlaylist(Playlist playlist, String newName) {
+
+    }
+}
diff --git a/src/main/java/org/example/repo/SongRepository.java b/src/main/java/org/example/repo/SongRepository.java
new file mode 100644
index 00000000..0eeccc04
--- /dev/null
+++ b/src/main/java/org/example/repo/SongRepository.java
@@ -0,0 +1,25 @@
+package org.example.repo;
+
+import org.example.entity.Album;
+import org.example.entity.Artist;
+import org.example.entity.Song;
+
+import java.util.List;
+
+public interface SongRepository {
+    Long count();
+
+    boolean existsByUniqueId(Song song);
+
+    void save(Song song);
+
+    List<Song> findAll();
+
+    List<Song> findByArtist(Artist artist);
+
+    // Redundant?
+    List<Song> findByAlbum(Album album);
+
+    List<Song> findByGenre(String genre);
+
+}
diff --git a/src/main/java/org/example/repo/SongRepositoryImpl.java b/src/main/java/org/example/repo/SongRepositoryImpl.java
new file mode 100644
index 00000000..b80e4696
--- /dev/null
+++ b/src/main/java/org/example/repo/SongRepositoryImpl.java
@@ -0,0 +1,104 @@
+package org.example.repo;
+
+import jakarta.persistence.EntityManagerFactory;
+import org.example.PersistenceManager;
+import org.example.entity.Album;
+import org.example.entity.Artist;
+import org.example.entity.Song;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SongRepositoryImpl implements SongRepository {
+
+    private final EntityManagerFactory emf = PersistenceManager.getEntityManagerFactory();
+
+
+    @Override
+    public Long count() {
+        try (var em = emf.createEntityManager()) {
+            return em.createQuery("select count(s) from Song s", Long.class)
+                .getSingleResult();
+        }
+    }
+
+    @Override
+    public boolean existsByUniqueId(Song song) {
+        try (var em = emf.createEntityManager()) {
+            return em.createQuery("select count(s) from Song s where s.songId = :songId", Long.class)
+                .setParameter("songId", song.getSongId())
+                .getSingleResult() > 0;
+        }
+    }
+
+
+    @Override
+    public void save(Song song) {
+        emf.runInTransaction(em -> em.persist(song));
+    }
+
+    @Override
+    public List<Song> findAll() {
+        return emf.callInTransaction(em ->
+            em.createQuery("select s from Song s", Song.class)
+                .getResultList());
+    }
+
+    @Override
+    public List<Song> findByArtist(Artist artist) {
+        if (artist == null) return new ArrayList<>();
+
+        return emf.callInTransaction(em ->
+            em.createQuery(
+                    """
+                        select s
+                        from Song s
+                        join fetch s.album a
+                        join fetch a.artist art
+                        where art = :artist
+                        """,
+                    Song.class
+                )
+                .setParameter("artist", artist)
+                .getResultList());
+    }
+
+
+    @Override
+    public List<Song> findByAlbum(Album album) {
+        if (album == null) return new ArrayList<>();
+
+        return emf.callInTransaction(em ->
+            em.createQuery(
+                    """
+                        select s
+                        from Song s
+                        join fetch s.album a
+                        join fetch a.artist art
+                        where a = :album
+                        """,
+                    Song.class
+                )
+                .setParameter("album", album)
+                .getResultList());
+    }
+
+    @Override
+    public List<Song> findByGenre(String genre) {
+        if (genre == null || genre.isBlank()) return new ArrayList<>();
+
+        return emf.callInTransaction(em ->
+            em.createQuery(
+                    """
+                        select s
+                        from Song s
+                        join fetch s.album a
+                        join fetch a.artist art
+                        where lower(a.genre) = lower(:genre)
+                        """,
+                    Song.class
+                )
+                .setParameter("genre", genre)
+                .getResultList());
+    }
+}
diff --git a/src/main/resources/ipod_style.css b/src/main/resources/ipod_style.css
new file mode 100644
index 00000000..44179daf
--- /dev/null
+++ b/src/main/resources/ipod_style.css
@@ -0,0 +1,125 @@
+/* --- GEMENSAMMA GRUNDER --- */
+.ipod-body {
+    -fx-background-color: #D3D3D3;
+}
+
+/* --- MYPOD: SKÄRMEN (iPod-stil) --- */
+.ipod-screen {
+    -fx-background-color: white;
+    -fx-border-color: #999;
+    -fx-border-width: 2;
+    -fx-background-radius: 10;
+    -fx-border-radius: 10;
+}
+
+.screen-title {
+    -fx-text-fill: #333333;
+    -fx-font-size: 14pt;
+    -fx-font-weight: bold;
+    -fx-padding: 0 0 5px 0;
+    -fx-border-color: #ccc;
+    -fx-border-width: 0 0 1 0;
+}
+
+.menu-item {
+    -fx-text-fill: #333333;
+    -fx-font-size: 11pt;
+    -fx-padding: 2px 5px 2px 5px;
+    -fx-font-family: "Lucida Console";
+}
+
+.selected-item {
+    -fx-background-color: #333333;
+    -fx-text-fill: #ffffff;
+}
+
+/* --- MYPOD: KLICKHJULET --- */
+.outer-wheel {
+    -fx-fill: linear-gradient(#eee, #ccc);
+    -fx-stroke: #888;
+}
+
+.center-button {
+    -fx-fill: linear-gradient(#ddd, #bbb);
+    -fx-stroke: #777;
+}
+
+.wheel-text, .wheel-text-menu, .wheel-text-play {
+    -fx-fill: #333333;
+    -fx-font-family: "Arial";
+    -fx-font-weight: bold;
+}
+
+/* Positionering av texter på hjulet */
+.wheel-text-menu { -fx-translate-y: -70px; -fx-font-size: 10pt; }
+.wheel-text-play { -fx-translate-y: 70px; -fx-font-size: 10pt; }
+#ff-button       { -fx-translate-x: 70px; -fx-font-size: 12pt; }
+#rew-button      { -fx-translate-x: -70px; -fx-font-size: 12pt; }
+
+/* --- ITUNES: PANELER & KONTROLLER --- */
+.top-panel {
+    -fx-background-color: linear-gradient(to bottom, #dcdcdc, #bebebe);
+    -fx-border-color: #999;
+    -fx-border-width: 0 0 1 0;
+}
+
+.bottom-panel {
+    -fx-background-color: linear-gradient(to bottom, #dcdcdc, #bebebe);
+    -fx-border-color: #999;
+    -fx-border-width: 1 0 0 0; /* En mörkare linje i överkant */
+    -fx-padding: 10;
+}
+
+.itunes-search {
+    -fx-background-radius: 15;
+    -fx-border-radius: 15;
+    -fx-border-color: #aaa;
+    -fx-background-color: white;
+}
+
+.itunes-button {
+    -fx-background-radius: 50;
+    -fx-min-width: 35;
+    -fx-min-height: 35;
+}
+
+.list-control-button {
+    -fx-min-width: 30px;
+
+    -fx-min-height: 30px;
+    -fx-max-height: 30px;
+
+    /* Ta bort inre marginaler så tecknet får plats */
+    -fx-padding: 0;
+
+    /* Centrera tecknet */
+    -fx-alignment: center;
+    -fx-text-alignment: center;
+
+    -fx-font-size: 16px; /* Justera storleken på tecknet här */
+    -fx-font-weight: bold;
+
+    -fx-background-radius: 5;
+    -fx-border-radius: 5;
+    -fx-border-color: #999;
+}
+
+/* iTunes LCD */
+.lcd-background {
+    -fx-fill: white;
+    -fx-stroke: gray;
+    -fx-arc-width: 10;
+    -fx-arc-height: 10;
+}
+
+.lcd-title { -fx-font-family: "Lucida Console"; -fx-font-weight: bold; }
+.lcd-artist { -fx-fill: darkslategray; -fx-font-family: "Lucida Console"; }
+
+/* iTunes Tabell och lista */
+.source-list, .song-table {
+    -fx-font-family: "Lucida Console";
+}
+.source-list {
+    -fx-background-color: #ebf1f7;
+    -fx-control-inner-background: #ebf1f7;
+}