Rename DeleteArtistHandle to DeleteArtistHandler for consistency and update related references. Clean up Protobuf comment in UpdateArtistResponse.

- Correct references from "genre" to "artist" in logging statements.
- Remove unused `Genre` import for cleanup.

pom.xml

@@ -13,7 +13,7 @@
         <maven.compiler.target>17</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <hibernate.version>7.1.7.Final</hibernate.version>
-        <postgresql.version>42.7.5</postgresql.version>
+        <postgresql.version>42.7.7</postgresql.version>
         <hikaricp.version>5.1.0</hikaricp.version>
         <log4j.version>2.23.1</log4j.version>
         <junit.version>5.10.2</junit.version>
@@ -35,6 +35,12 @@
             <version>${hibernate.version}</version>
         </dependency>
 
+        <dependency>
+            <groupId>org.hibernate.orm</groupId>
+            <artifactId>hibernate-community-dialects</artifactId>
+            <version>${hibernate.version}</version>
+        </dependency>
+
         <!-- HikariCP for connection pooling -->
         <dependency>
             <groupId>com.zaxxer</groupId>
@@ -84,12 +90,15 @@
             <version>4.32.0</version>
         </dependency>
         <dependency>
-            <groupId>io.zonky.test</groupId>
-            <artifactId>embedded-postgres</artifactId>
-            <version>2.2.0</version>
+            <groupId>org.xerial</groupId>
+            <artifactId>sqlite-jdbc</artifactId>
+            <version>3.44.1.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.reflections</groupId>
+            <artifactId>reflections</artifactId>
+            <version>0.10.2</version>
         </dependency>
-
-
     </dependencies>
 
     <build>

src/main/java/com/mediamanager/MediaManagerApplication.java

@@ -1,5 +1,6 @@
 package com.mediamanager;
 
+import com.mediamanager.service.database.DatabaseManager;
 import com.mediamanager.service.delegate.DelegateActionManager;
 import com.mediamanager.service.ipc.IPCManager;
 import org.apache.logging.log4j.LogManager;
@@ -9,12 +10,12 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.util.Properties;
 
-import com.mediamanager.service.database.LocalDatabaseManager;
+import com.mediamanager.service.database.SqliteDatabaseManager;
 
 public class MediaManagerApplication {
     private static final Logger logger = LogManager.getLogger(MediaManagerApplication.class);
     private static Properties config;
-    private static LocalDatabaseManager databaseManager;
+    private static DatabaseManager databaseManager;
     private static DelegateActionManager actionManager;
     private static IPCManager ipcManager;
 
@@ -52,14 +53,14 @@ public class MediaManagerApplication {
             switch (mode) {
                 case LOCAL:
                     logger.info("Starting local database...");
-                    databaseManager = new LocalDatabaseManager(config);
+                    databaseManager = new SqliteDatabaseManager(config);
                     break;
                 case SERVER:
                     throw new Exception("Server mode not yet implemented");
                 default:
             }
             databaseManager.init();
-            actionManager = new DelegateActionManager();
+            actionManager = new DelegateActionManager(databaseManager.getEntityManagerFactory());
             actionManager.start();
             ipcManager = new IPCManager(config,actionManager);
             ipcManager.init();
@@ -135,4 +136,4 @@ public class MediaManagerApplication {
     public static Properties getConfig() {
         return config;
     }
-}
+}

src/main/java/com/mediamanager/mapper/ArtistMapper.java

@@ -0,0 +1,41 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.Artist;
+import com.mediamanager.protocol.messages.ArtistMessages;
+
+
+public class ArtistMapper {
+    public static ArtistMessages.Artist toProtobuf(Artist entity){
+        if (entity == null) {
+            return null;
+        }
+
+        String name = entity.getName();
+        if (name == null) {
+            throw new IllegalArgumentException("Artist name cannot be null");
+        }
+
+        ArtistMessages.Artist.Builder builder = ArtistMessages.Artist.newBuilder()
+                .setName(name);
+
+        // Only set ID when it's present and valid (> 0). Avoids NPE for null IDs.
+        Integer id = entity.getId();
+        if (id != null && id > 0) {
+            builder.setId(id);
+        }
+
+        return builder.build();
+    }
+    public static Artist toEntity(ArtistMessages.Artist protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+        Artist entity = new Artist();
+
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+        entity.setName(protobuf.getName());
+        return entity;
+    }
+}

src/main/java/com/mediamanager/mapper/GenreMapper.java

@@ -0,0 +1,40 @@
+package com.mediamanager.mapper;
+
+import com.mediamanager.model.Genre;
+import com.mediamanager.protocol.messages.GenreMessages;
+
+public class GenreMapper {
+    public static GenreMessages.Genre toProtobuf(Genre entity) {
+        if (entity == null) {
+            return null;
+        }
+
+        GenreMessages.Genre.Builder builder = GenreMessages.Genre.newBuilder()
+                .setName(entity.getName());
+
+        // Only set ID when it's present and valid (> 0). Avoids NPE for null IDs.
+        Integer id = entity.getId();
+        if (id != null && id > 0) {
+            builder.setId(id);
+        }
+
+        return builder.build();
+    }
+    public static Genre toEntity(GenreMessages.Genre protobuf) {
+        if (protobuf == null) {
+            return null;
+        }
+
+        Genre entity = new Genre();
+
+        // Só seta ID se for > 0 (protobuf default é 0)
+        if (protobuf.getId() > 0) {
+            entity.setId(protobuf.getId());
+        }
+
+        entity.setName(protobuf.getName());
+
+        return entity;
+    }
+}
+

src/main/java/com/mediamanager/model/Artist.java

@@ -0,0 +1,27 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "artist")
+public class Artist {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(nullable = false)
+    private String name;
+
+    public Integer getId() {
+        return id;
+    }
+    public void setId(Integer id) {
+        this.id = id;
+    }
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
+}

src/main/java/com/mediamanager/model/Genre.java

@@ -0,0 +1,30 @@
+package com.mediamanager.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "genre")
+public class Genre {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(nullable = false)
+    private String name;
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

src/main/java/com/mediamanager/model/Media.java

@@ -1,128 +0,0 @@
-package com.mediamanager.model;
-
-import jakarta.persistence.*;
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "media")
-public class Media {
-    
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    
-    @Column(nullable = false)
-    private String title;
-    
-    @Column(nullable = false, unique = true)
-    private String filePath;
-    
-    @Enumerated(EnumType.STRING)
-    @Column(nullable = false)
-    private MediaType type;
-    
-    @Column
-    private Long fileSize;
-    
-    @Column
-    private String mimeType;
-    
-    @Column(name = "created_at", nullable = false, updatable = false)
-    private LocalDateTime createdAt;
-    
-    @Column(name = "updated_at")
-    private LocalDateTime updatedAt;
-    
-    @PrePersist
-    protected void onCreate() {
-        createdAt = LocalDateTime.now();
-        updatedAt = LocalDateTime.now();
-    }
-    
-    @PreUpdate
-    protected void onUpdate() {
-        updatedAt = LocalDateTime.now();
-    }
-    
-    // Constructors
-    public Media() {}
-    
-    public Media(String title, String filePath, MediaType type) {
-        this.title = title;
-        this.filePath = filePath;
-        this.type = type;
-    }
-    
-    // Getters and Setters
-    public Long getId() {
-        return id;
-    }
-    
-    public void setId(Long id) {
-        this.id = id;
-    }
-    
-    public String getTitle() {
-        return title;
-    }
-    
-    public void setTitle(String title) {
-        this.title = title;
-    }
-    
-    public String getFilePath() {
-        return filePath;
-    }
-    
-    public void setFilePath(String filePath) {
-        this.filePath = filePath;
-    }
-    
-    public MediaType getType() {
-        return type;
-    }
-    
-    public void setType(MediaType type) {
-        this.type = type;
-    }
-    
-    public Long getFileSize() {
-        return fileSize;
-    }
-    
-    public void setFileSize(Long fileSize) {
-        this.fileSize = fileSize;
-    }
-    
-    public String getMimeType() {
-        return mimeType;
-    }
-    
-    public void setMimeType(String mimeType) {
-        this.mimeType = mimeType;
-    }
-    
-    public LocalDateTime getCreatedAt() {
-        return createdAt;
-    }
-    
-    public void setCreatedAt(LocalDateTime createdAt) {
-        this.createdAt = createdAt;
-    }
-    
-    public LocalDateTime getUpdatedAt() {
-        return updatedAt;
-    }
-    
-    public void setUpdatedAt(LocalDateTime updatedAt) {
-        this.updatedAt = updatedAt;
-    }
-    
-    public enum MediaType {
-        VIDEO,
-        AUDIO,
-        IMAGE,
-        DOCUMENT,
-        OTHER
-    }
-}

src/main/java/com/mediamanager/repository/ArtistRepository.java

@@ -0,0 +1,104 @@
+package com.mediamanager.repository;
+import com.mediamanager.model.Artist;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class ArtistRepository {
+    private static final Logger logger = LogManager.getLogger(ArtistRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public ArtistRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    public Artist save(Artist artist){
+        logger.debug("Saving Artist: {}", artist.getName());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(artist);
+            em.getTransaction().commit();
+            logger.debug("Artist saved with ID: {}", artist.getId());
+            return artist;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error saving Artist", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public List<Artist> findAll(){
+        logger.debug("Finding all Artists");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try {
+            return em
+                    .createQuery("SELECT a FROM Artist a ORDER BY a.name", Artist.class)
+                    .getResultList();
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public Optional<Artist> findById(Integer id){
+        logger.debug("Finding artist by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try {
+            Artist artist = em.find(Artist.class, id);
+            return Optional.ofNullable(artist);
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+
+    }
+
+    public Artist update(Artist artist){
+        logger.debug("Updating artist ID: {}", artist.getId());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            Artist updated = em.merge(artist);
+            em.getTransaction().commit();
+            logger.debug("Artist updated successfully");
+            return updated;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error updating artist", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    public boolean deleteById(Integer id){
+        logger.debug("Deleting Artist by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            Artist artist = em.find(Artist.class, id);
+            if (artist == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(artist);
+            em.getTransaction().commit();
+            logger.debug("Artist deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error deleting artist", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+        }
+
+

src/main/java/com/mediamanager/repository/GenreRepository.java

@@ -0,0 +1,121 @@
+package com.mediamanager.repository;
+
+import com.mediamanager.model.Genre;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Repository para acesso a dados de Genre
+ * Encapsula todas as operações de banco de dados
+ */
+public class GenreRepository {
+    private static final Logger logger = LogManager.getLogger(GenreRepository.class);
+
+    private final EntityManagerFactory entityManagerFactory;
+
+    public GenreRepository(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+    }
+
+    /**
+     * Salva um novo genre
+     */
+    public Genre save(Genre genre) {
+        logger.debug("Saving genre: {}", genre.getName());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            em.persist(genre);
+            em.getTransaction().commit();
+            logger.debug("Genre saved with ID: {}", genre.getId());
+            return genre;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error saving genre", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    /**
+     * Busca todos os genres
+     */
+    public List<Genre> findAll() {
+        logger.debug("Finding all genres");
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try {
+            return em
+                    .createQuery("SELECT g FROM Genre g ORDER BY g.name", Genre.class)
+                    .getResultList();
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    /**
+     * Busca genre por ID
+     */
+    public Optional<Genre> findById(Integer id) {
+        logger.debug("Finding genre by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        try {
+            Genre genre = em.find(Genre.class, id);
+            return Optional.ofNullable(genre);
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    /**
+     * Atualiza um genre existente
+     */
+    public Genre update(Genre genre) {
+        logger.debug("Updating genre ID: {}", genre.getId());
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            Genre updated = em.merge(genre);
+            em.getTransaction().commit();
+            logger.debug("Genre updated successfully");
+            return updated;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error updating genre", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+
+    /**
+     * Deleta um genre por ID
+     */
+    public boolean deleteById(Integer id) {
+        logger.debug("Deleting genre by ID: {}", id);
+        EntityManager em = entityManagerFactory.createEntityManager();
+        em.getTransaction().begin();
+        try {
+            Genre genre = em.find(Genre.class, id);
+            if (genre == null) {
+                em.getTransaction().rollback();
+                return false;
+            }
+            em.remove(genre);
+            em.getTransaction().commit();
+            logger.debug("Genre deleted successfully");
+            return true;
+        } catch (Exception e) {
+            em.getTransaction().rollback();
+            logger.error("Error deleting genre", e);
+            throw e;
+        } finally {
+            if (em.isOpen()) em.close();
+        }
+    }
+}

src/main/java/com/mediamanager/service/artist/ArtistService.java

@@ -0,0 +1,65 @@
+package com.mediamanager.service.artist;
+
+import com.mediamanager.model.Artist;
+import com.mediamanager.repository.ArtistRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+public class ArtistService {
+    private static final Logger logger = LogManager.getLogger(ArtistService.class);
+    private final ArtistRepository artistRepository;
+
+    public ArtistService(ArtistRepository artistRepository) {
+        this.artistRepository = artistRepository;
+    }
+
+    public Artist createArtist(String name){
+        logger.info("Creating artist: {}", name);
+        if (name == null || name.trim().isEmpty()) {
+            throw new IllegalArgumentException("Artist name cannot be empty");
+        }
+        Artist artist = new Artist();
+        artist.setName(name.trim());
+        return artistRepository.save(artist);
+    }
+
+    public List<Artist> getAllArtists(){
+        logger.info("Getting all artists");
+        return artistRepository.findAll();
+    }
+
+    public Optional<Artist> getArtistById(Integer id){
+        logger.info("Getting artist by ID: {}", id);
+        return artistRepository.findById(id);
+    }
+
+    public Optional<Artist> updateArtist(Integer id, String name){
+        logger.info("Updating artist ID {}: {}", id, name);
+
+        if (name == null || name.trim().isEmpty()) {
+            throw new IllegalArgumentException("Artist name cannot be empty");
+        }
+
+        Optional<Artist> existingArtist = artistRepository.findById(id);
+
+        if(existingArtist.isEmpty()){
+            logger.warn("Artist not found with ID: {}", id);
+            return Optional.empty();
+        }
+        Artist artist = existingArtist.get();
+        artist.setName(name.trim());
+        Artist updatedArtist = artistRepository.update(artist);
+        return Optional.of(updatedArtist);
+    }
+
+    public boolean deleteArtist(Integer id){
+        logger.info("Deleting artist ID: {}", id);
+        return artistRepository.deleteById(id);
+    }
+
+
+
+}

src/main/java/com/mediamanager/service/database/DatabaseManager.java

@@ -1,16 +1,24 @@
 package com.mediamanager.service.database;
 
+import jakarta.persistence.EntityManagerFactory;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-
+import org.hibernate.cfg.Configuration;
+import org.reflections.Reflections;
+import org.reflections.scanners.Scanners;
+import jakarta.persistence.Entity;
+import java.util.Set;
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.Properties;
 
+
 public abstract class DatabaseManager {
     protected final Properties configuration;
     protected Connection connection;
+    protected String connectionUrl;
+    protected EntityManagerFactory entityManagerFactory;
     protected static final Logger logger = LogManager.getLogger(DatabaseManager.class);
 
     public DatabaseManager(Properties config) {
@@ -38,6 +46,14 @@ public abstract class DatabaseManager {
     }
 
     public void close() {
+        if (entityManagerFactory != null && entityManagerFactory.isOpen()) {
+            try {
+                entityManagerFactory.close();
+                logger.info("EntityManagerFactory closed");
+            } catch (Exception e) {
+                logger.error("Error closing EntityManagerFactory: {}", e.getMessage());
+            }
+        }
         if (connection != null) {
             try {
                 logger.info("Closing database connection...");
@@ -50,6 +66,7 @@ public abstract class DatabaseManager {
             logger.debug("No database connection to close");
         }
     }
+
     protected boolean testConnection() {
         try (Statement stmt = connection.createStatement()) {
             stmt.execute("SELECT 1");
@@ -59,4 +76,67 @@ public abstract class DatabaseManager {
             return false;
         }
     }
-}
+    protected void initializeHibernate() {
+        logger.info("Initializing Hibernate ORM...");
+
+        Configuration hibernateConfig = new Configuration();
+
+
+        String dialect = configuration.getProperty("hibernate.dialect");
+        String hbm2ddl = configuration.getProperty("hibernate.hbm2ddl.auto");
+        String driver = configuration.getProperty("database.driver");
+
+        if (dialect == null || dialect.isEmpty()) {
+            throw new IllegalStateException("hibernate.dialect property is required but not configured");
+        }
+        if (driver == null || driver.isEmpty()) {
+            throw new IllegalStateException("database.driver property is required but not configured");
+        }
+        if (connectionUrl == null || connectionUrl.isEmpty()) {
+             throw new IllegalStateException("connectionUrl must be set before initializing Hibernate");
+        }
+
+
+        hibernateConfig.setProperty("hibernate.connection.url", connectionUrl);
+        hibernateConfig.setProperty("hibernate.connection.driver_class", driver);
+        hibernateConfig.setProperty("hibernate.dialect", dialect);
+        hibernateConfig.setProperty("hibernate.hbm2ddl.auto", hbm2ddl);
+        hibernateConfig.setProperty("hibernate.show_sql",
+                configuration.getProperty("hibernate.show_sql", "false"));
+        hibernateConfig.setProperty("hibernate.format_sql",
+                configuration.getProperty("hibernate.format_sql", "true"));
+
+        logger.info("Scanning for entities in package: com.mediamanager.model");
+
+        Set<Class<?>> entityClasses;
+        try {
+            Reflections reflections = new Reflections("com.mediamanager.model", Scanners.TypesAnnotated);
+            entityClasses = reflections.getTypesAnnotatedWith(Entity.class);
+            } catch (Exception e) {
+            logger.error("Failed to scan for entities: {}", e.getMessage());
+            throw new RuntimeException("Entity scanning failed", e);
+            }
+
+        logger.info("Found {} entities", entityClasses.size());
+        if (entityClasses.isEmpty()) {
+            logger.warn("No @Entity classes found in package com.mediamanager.model - is this expected?");
+        }
+        for (Class<?> entityClass : entityClasses) {
+            logger.debug("Registering entity: {}", entityClass.getSimpleName());
+            hibernateConfig.addAnnotatedClass(entityClass);
+        }
+
+        try {
+            entityManagerFactory = hibernateConfig.buildSessionFactory().unwrap(EntityManagerFactory.class);
+            } catch (Exception e) {
+            logger.error("Failed to initialize Hibernate: {}", e.getMessage());
+            throw new RuntimeException("Hibernate initialization failed", e);
+            }
+
+        logger.info("Hibernate ORM initialized successfully");
+    }
+
+    public EntityManagerFactory getEntityManagerFactory() {
+        return entityManagerFactory;
+    }
+}

src/main/java/com/mediamanager/service/database/LocalDatabaseManager.java

@@ -1,87 +0,0 @@
-package com.mediamanager.service.database;
-
-import io.zonky.test.db.postgres.embedded.EmbeddedPostgres;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.sql.Connection;
-import java.util.Properties;
-
-public class LocalDatabaseManager extends DatabaseManager {
-    private static final Logger logger = LogManager.getLogger(LocalDatabaseManager.class);
-    private EmbeddedPostgres embeddedPostgres;
-
-    public LocalDatabaseManager(Properties config) {
-        super(config);
-    }
-
-    @Override
-    public void init() throws Exception {
-        logger.info("Initializing embedded PostgreSQL database...");
-
-        // Configurações específicas do modo local
-        String dataDir = configuration.getProperty("local.database.dir",
-                System.getProperty("user.home") + "/.mediamanager/db");
-        int port = Integer.parseInt(
-                configuration.getProperty("local.database.port", "54321")
-        );
-
-        // Cria diretório se não existir
-        Path dataPath = Paths.get(dataDir);
-        Files.createDirectories(dataPath);
-        logger.debug("Using data directory: {}", dataDir);
-
-        // Inicia o PostgreSQL embedded
-        logger.info("Starting embedded PostgreSQL on port {}", port);
-        embeddedPostgres = EmbeddedPostgres.builder()
-                .setDataDirectory(dataPath)
-                .setCleanDataDirectory(false)  // Mantém dados
-                .setPort(port)
-                .start();
-
-        // Cria a conexão
-        this.connection = createConnection();
-        logger.info("Embedded database connection established successfully");
-
-        // Usa o método da classe pai para sanity checks
-        performSanityChecks();
-        logger.info("Database sanity checks passed successfully");
-    }
-
-    @Override
-    protected Connection createConnection() throws Exception {
-        if (embeddedPostgres == null) {
-            throw new IllegalStateException("Embedded PostgreSQL not started");
-        }
-
-        try {
-            // Pega conexão do embedded
-            Connection conn = embeddedPostgres.getPostgresDatabase().getConnection();
-            logger.debug("Got connection from embedded PostgreSQL");
-            return conn;
-        } catch (Exception e) {
-            logger.error("Failed to get embedded connection", e);
-            throw new Exception("Embedded connection failed: " + e.getMessage(), e);
-        }
-    }
-
-    @Override
-    public void close() {
-        // Primeiro fecha a conexão (método da classe pai)
-        super.close();
-
-        // Depois para o embedded
-        if (embeddedPostgres != null) {
-            try {
-                logger.info("Stopping embedded PostgreSQL...");
-                embeddedPostgres.close();
-                logger.info("Embedded PostgreSQL stopped successfully");
-            } catch (Exception e) {
-                logger.error("Error stopping embedded PostgreSQL", e);
-            }
-        }
-    }
-}

src/main/java/com/mediamanager/service/database/SqliteDatabaseManager.java

@@ -0,0 +1,99 @@
+package com.mediamanager.service.database;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Properties;
+
+public class SqliteDatabaseManager extends DatabaseManager {
+    private static final Logger logger = LogManager.getLogger(SqliteDatabaseManager.class);
+
+
+
+
+    public SqliteDatabaseManager(Properties config) {
+        super(config);
+    }
+
+        @Override
+        public void init() throws Exception {
+
+            logger.info("Initializing SQLite database...");
+            String dataDir = configuration.getProperty("database.dir",
+                    System.getProperty("user.home") + "/.mediamanager/db");
+            String dbFilename = configuration.getProperty("database.filename", "mediamanager.db");
+            String driverClassName = configuration.getProperty("database.driver", "org.sqlite.JDBC");
+            try {
+                Class.forName(driverClassName);
+            }catch(ClassNotFoundException e) {
+                logger.error("Failed to load SQLite driver", e);
+                throw e;
+            }
+            Path dataPath = Paths.get(dataDir);
+            if (!Files.exists(dataPath)) {
+                Files.createDirectories(dataPath);
+                logger.debug("Created database directory: {}", dataDir);
+            }
+            Path dbFile = dataPath.resolve(dbFilename);
+            this.connectionUrl = "jdbc:sqlite:" + dbFile.toAbsolutePath().toString();
+            logger.info("Database file path: {}", dbFile);
+            logger.info("Connection URL: {}", this.connectionUrl);
+            initializeHibernate();
+            this.connection = createConnection();
+            configurePerformancePragmas();
+            performSanityChecks();
+            ensureSchemaExists();
+            logger.info("SQLite database initialized successfully");
+
+
+    }
+
+    @Override
+    protected Connection createConnection() throws Exception {
+        try {
+            // O driver org.xerial.sqlite-jdbc é carregado automaticamente aqui
+            Connection conn = DriverManager.getConnection(this.connectionUrl);
+            logger.debug("Got connection to SQLite file");
+            return conn;
+        } catch (SQLException e) {
+            logger.error("Failed to create SQLite connection", e);
+            throw new Exception("SQLite connection failed: " + e.getMessage(), e);
+        }
+    }
+
+
+    private void configurePerformancePragmas() throws SQLException {
+        try (Statement stmt = connection.createStatement()) {
+
+            stmt.execute("PRAGMA journal_mode=WAL;");
+
+
+            stmt.execute("PRAGMA foreign_keys=ON;");
+
+
+            stmt.execute("PRAGMA synchronous=NORMAL;");
+
+            stmt.execute("PRAGMA busy_timeout=5000;");
+
+            logger.debug("SQLite performance PRAGMAs applied (WAL, Synchronous, ForeignKeys).");
+        }
+    }
+
+    private void ensureSchemaExists() throws SQLException {
+
+    }
+
+    @Override
+    public void close() {
+
+        super.close();
+        logger.info("SQLite resources released.");
+    }
+}

src/main/java/com/mediamanager/service/delegate/DelegateActionManager.java

@@ -2,29 +2,66 @@ package com.mediamanager.service.delegate;
 
 import com.google.protobuf.ByteString;
 import com.mediamanager.protocol.TransportProtocol;
-import com.mediamanager.service.delegate.handler.EchoHandler;
+import com.mediamanager.repository.ArtistRepository;
+import com.mediamanager.repository.GenreRepository;
+import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.delegate.annotation.Action;
+
+import com.mediamanager.service.genre.GenreService;
+import jakarta.persistence.EntityManagerFactory;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.reflections.Reflections;
+import org.reflections.scanners.Scanners;
+import java.lang.reflect.Constructor;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Set;
 
 public class DelegateActionManager {
     private static final Logger logger = LogManager.getLogger(DelegateActionManager.class);
     
     private final Map<String, ActionHandler> handlerRegistry;
-    
-    public DelegateActionManager() {
-        
+    private final ServiceLocator serviceLocator;
+    private final EntityManagerFactory entityManagerFactory;
+
+
+    public DelegateActionManager(EntityManagerFactory entityManagerFactory) {
+        this.entityManagerFactory = entityManagerFactory;
+        this.serviceLocator = new ServiceLocator();
+
+        initializeServices();
+
+
         logger.debug("DelegateActionManager created");
         this.handlerRegistry = new HashMap<>();
-        registerHandlers();
+        autoRegisterHandlers();
+
     }
 
-    private void registerHandlers() {
-        handlerRegistry.put("echo",new EchoHandler());
+    private void initializeServices() {
+        logger.info("Initializing services...");
+
+
+        GenreRepository genreRepository = new GenreRepository(entityManagerFactory);
+        GenreService genreService = new GenreService(genreRepository);
+
+
+        serviceLocator.register(GenreService.class, genreService);
+
+        ArtistRepository artistRepository = new ArtistRepository(entityManagerFactory);
+        ArtistService artistService = new ArtistService(artistRepository);
+
+        serviceLocator.register(ArtistService.class, artistService);
+
+        serviceLocator.logRegisteredServices();
+
+        logger.info("Services initialized successfully");
     }
 
+
+
     public void start(){
         logger.info("DelegateActionManager started");
     }
@@ -33,6 +70,117 @@ public class DelegateActionManager {
         logger.info("DelegateActionManager stopped");
     }
 
+    @SuppressWarnings("unchecked")
+    private ActionHandler instantiateHandler(Class<?> clazz) throws Exception {
+        if(!ActionHandler.class.isAssignableFrom(clazz)){
+            throw new IllegalArgumentException(
+                    clazz.getName() + " is annotated with @Action but does not implement ActionHandler");
+
+        }
+        logger.debug("Attempting to instantiate handler: {}", clazz.getSimpleName());
+
+
+        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+
+
+        // Sort constructors by parameter count (descending) to prefer DI constructors
+        java.util.Arrays.sort(constructors, (c1, c2) -> 
+            Integer.compare(c2.getParameterCount(), c1.getParameterCount()));
+
+        for (Constructor<?> constructor : constructors) {
+
+            Class<?>[] paramTypes = constructor.getParameterTypes();
+
+
+            Object[] params = new Object[paramTypes.length];
+            boolean allDependenciesResolved = true;
+
+            for (int i = 0; i < paramTypes.length; i++) {
+
+                Object service = serviceLocator.get(paramTypes[i]);
+
+                if (service == null) {
+
+                    allDependenciesResolved = false;
+                    logger.debug("Cannot resolve dependency {} for {}",
+                            paramTypes[i].getSimpleName(),
+                            clazz.getSimpleName());
+                    break;  // Para de tentar esse construtor
+                }
+
+
+                params[i] = service;
+            }
+
+
+            if (allDependenciesResolved) {
+                logger.debug("Using constructor with {} params for {}",
+                        paramTypes.length, clazz.getSimpleName());
+                return (ActionHandler) constructor.newInstance(params);
+            }
+        }
+
+
+        throw new IllegalStateException(
+                String.format(
+                        "Cannot instantiate handler %s. No suitable constructor found. " +
+                                "Make sure all required services are registered in ServiceLocator.",
+                        clazz.getName()
+                )
+        );
+    }
+
+    private void autoRegisterHandlers() {
+        logger.info("Starting auto-registration of handlers...");
+        Reflections reflections = new Reflections(
+                "com.mediamanager.service.delegate.handler",
+                Scanners.TypesAnnotated
+        );
+        Set<Class<?>> annotatedClasses = reflections.getTypesAnnotatedWith(Action.class);
+        logger.info("Found {} handler classes with @Action annotation", annotatedClasses.size());
+        int successCount = 0;
+        int failureCount = 0;
+        for (Class<?> handlerClass : annotatedClasses) {
+            try {
+
+                Action actionAnnotation = handlerClass.getAnnotation(Action.class);
+                String actionName = actionAnnotation.value();
+
+                logger.debug("Processing handler: {} for action '{}'",
+                        handlerClass.getSimpleName(),
+                        actionName);
+
+
+                ActionHandler handler = instantiateHandler(handlerClass);
+
+
+                handlerRegistry.put(actionName, handler);
+
+                logger.info("✓ Registered handler: '{}' -> {}",
+                        actionName,
+                        handlerClass.getSimpleName());
+                successCount++;
+
+            } catch (Exception e) {
+
+                logger.error("✗ Failed to register handler: {}",
+                        handlerClass.getName(),
+                        e);
+                failureCount++;
+            }
+        }
+
+
+        logger.info("Auto-registration complete: {} successful, {} failed, {} total",
+                successCount,
+                failureCount,
+                successCount + failureCount);
+
+        if (failureCount > 0) {
+            logger.warn("Some handlers failed to register. Check logs above for details.");
+        }
+    }
+
     public TransportProtocol.Response ProcessedRequest(TransportProtocol.Request request){
         String requestId = request.getRequestId();
         logger.info("Processing request: {}", requestId);

src/main/java/com/mediamanager/service/delegate/ServiceLocator.java

@@ -0,0 +1,45 @@
+package com.mediamanager.service.delegate;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ServiceLocator {
+    private static final Logger logger = LogManager.getLogger(ServiceLocator.class);
+    private final Map<Class<?>, Object> services = new HashMap<>();
+
+    public <T> void register(Class<T> serviceClass, T serviceInstance) {
+        if (serviceInstance == null) {
+            throw new IllegalArgumentException("Service instance cannot be null");
+        }
+        services.put(serviceClass, serviceInstance);
+        logger.debug("Registered service: {} -> {}",
+                serviceClass.getSimpleName(),
+                serviceInstance.getClass().getSimpleName());
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T> T get(Class<T> serviceClass) {
+        return (T) services.get(serviceClass);
+    }
+
+    public boolean has(Class<?> serviceClass) {
+        return services.containsKey(serviceClass);
+    }
+    public int size() {
+        return services.size();
+    }
+    public void logRegisteredServices() {
+        logger.info("Registered services: {}", services.size());
+
+
+        services.forEach((clazz, instance) ->
+                logger.info("  - {} -> {}",
+                        clazz.getSimpleName(),
+                        instance.getClass().getSimpleName())
+        );
+    }
+}
+

src/main/java/com/mediamanager/service/delegate/annotation/Action.java

@@ -0,0 +1,13 @@
+package com.mediamanager.service.delegate.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface Action {
+
+    String value();
+}

src/main/java/com/mediamanager/service/delegate/handler/CloseHandler.java

@@ -0,0 +1,34 @@
+package com.mediamanager.service.delegate.handler;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TestProtocol.CloseCommand;
+import com.mediamanager.protocol.TestProtocol.CloseResponse;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("close")
+public class CloseHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CloseHandler.class);
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        CloseCommand.parseFrom(requestPayload); // Valida
+
+        logger.info("Close command received - connection will close");
+
+        CloseResponse response = CloseResponse.newBuilder()
+                .setMessage("Connection closing. Goodbye!")
+                .build();
+
+        return TransportProtocol.Response.newBuilder()
+                .setPayload(ByteString.copyFrom(response.toByteArray()))
+                .setStatusCode(200)
+                .putHeaders("Connection", "close"); // ← Marca para fechar
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/EchoHandler.java

@@ -1,17 +1,41 @@
 package com.mediamanager.service.delegate.handler;
 
 import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TestProtocol.EchoCommand;      // ← Import
+import com.mediamanager.protocol.TestProtocol.EchoResponse;    // ← Import
 import com.mediamanager.protocol.TransportProtocol;
 import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
+@Action("echo")
 public class EchoHandler implements ActionHandler {
-    @Override
-    public TransportProtocol.Response.Builder handle(ByteString requestPayload) {
-        String payloadText = requestPayload.toStringUtf8();
-        String responseText = "Server received: " + payloadText;
+    private static final Logger logger = LogManager.getLogger(EchoHandler.class);
 
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {  // ← Pode lançar exceção
+
+        // 1. Parse Protobuf bytes → EchoCommand
+        EchoCommand command = EchoCommand.parseFrom(requestPayload);
+
+        logger.debug("Echo received: {}", command.getMessage());
+
+        // 2. Cria EchoResponse (Protobuf)
+        EchoResponse echoResponse = EchoResponse.newBuilder()
+                .setMessage(command.getMessage())
+                .setServerTimestamp(System.currentTimeMillis())
+                .build();
+
+        // 3. Serializa EchoResponse → bytes
+        ByteString responsePayload = ByteString.copyFrom(echoResponse.toByteArray());
+
+        // 4. Retorna Response
         return TransportProtocol.Response.newBuilder()
-                .setPayload(ByteString.copyFromUtf8(responseText))
+                .setPayload(responsePayload)
                 .setStatusCode(200);
+
     }
 }

src/main/java/com/mediamanager/service/delegate/handler/HeartbeatHandler.java

@@ -0,0 +1,38 @@
+package com.mediamanager.service.delegate.handler;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TestProtocol.HeartbeatCommand;
+import com.mediamanager.protocol.TestProtocol.HeartbeatResponse;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("heartbeat")
+public class HeartbeatHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(HeartbeatHandler.class);
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        HeartbeatCommand command = HeartbeatCommand.parseFrom(requestPayload);
+
+        long serverTime = System.currentTimeMillis();
+
+        logger.debug("Heartbeat received. Client T1={}, Server T2={}",
+                command.getClientTimestamp(), serverTime);
+
+        HeartbeatResponse response = HeartbeatResponse.newBuilder()
+                .setClientTimestamp(command.getClientTimestamp())  // Echo T1
+                .setServerTimestamp(serverTime)                     // T2
+                .build();
+
+        return TransportProtocol.Response.newBuilder()
+                .setPayload(ByteString.copyFrom(response.toByteArray()))
+                .setStatusCode(200);
+
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/artist/CreateArtistHandler.java

@@ -0,0 +1,50 @@
+package com.mediamanager.service.delegate.handler.artist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.ArtistMapper;
+import com.mediamanager.model.Artist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ArtistMessages;
+import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("artist.create")
+public class CreateArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateArtistHandler.class);
+    private final ArtistService artistService;
+
+    public CreateArtistHandler(ArtistService artistService) {
+        this.artistService = artistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            ArtistMessages.CreateArtistRequest createRequest =
+                    ArtistMessages.CreateArtistRequest.parseFrom(requestPayload);
+            Artist artist = artistService.createArtist(createRequest.getName());
+            ArtistMessages.Artist artistProto = ArtistMapper.toProtobuf(artist);
+            ArtistMessages.CreateArtistResponse createArtistResponse = ArtistMessages.CreateArtistResponse.newBuilder()
+                    .setArtist(artistProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createArtistResponse.toByteString());
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+
+        } catch (Exception e) {
+            logger.error("Error creating artist", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}
+

src/main/java/com/mediamanager/service/delegate/handler/artist/DeleteArtistHandler.java

@@ -0,0 +1,62 @@
+package com.mediamanager.service.delegate.handler.artist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ArtistMessages;
+import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("artist.delete")
+public class DeleteArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(DeleteArtistHandler.class);
+
+    private final ArtistService artistService;
+
+    public DeleteArtistHandler(ArtistService artistService) {
+        this.artistService = artistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+
+        try {
+            ArtistMessages.DeleteArtistRequest deleteRequest =
+                    ArtistMessages.DeleteArtistRequest.parseFrom(requestPayload);
+            int id = deleteRequest.getId();
+            boolean success = artistService.deleteArtist(id);
+            ArtistMessages.DeleteArtistResponse deleteResponse;
+            if (success) {
+                deleteResponse = ArtistMessages.DeleteArtistResponse.newBuilder()
+                        .setSuccess(true)
+                        .setMessage("Artist deleted successfully")
+                        .build();
+                return TransportProtocol.Response.newBuilder()
+                        .setPayload(deleteResponse.toByteString());
+            } else {
+                deleteResponse = ArtistMessages.DeleteArtistResponse.newBuilder()
+                        .setSuccess(false)
+                        .setMessage("Artist not found")
+                        .build();
+
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(deleteResponse.toByteString());
+            }
+        } catch (Exception e) {
+            logger.error("Error deleting artist", e);
+            ArtistMessages.DeleteArtistResponse deleteResponse =
+                    ArtistMessages.DeleteArtistResponse.newBuilder()
+                            .setSuccess(false)
+                            .setMessage("Error: " + e.getMessage())
+                            .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(deleteResponse.toByteString());
+        }
+    }
+    }

src/main/java/com/mediamanager/service/delegate/handler/artist/GetArtistByIdHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.artist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.ArtistMapper;
+import com.mediamanager.model.Artist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ArtistMessages;
+import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action(value = "artist.getById")
+public class GetArtistByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetArtistByIdHandler.class);
+    private final ArtistService artistService;
+
+    public GetArtistByIdHandler(ArtistService artistService) {
+        this.artistService = artistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+        throws InvalidProtocolBufferException{
+
+        try{
+            ArtistMessages.GetArtistByIdRequest getByIdRequest =
+                    ArtistMessages.GetArtistByIdRequest.parseFrom(requestPayload);
+            int id = getByIdRequest.getId();
+
+            Optional<Artist> artistOpt = artistService.getArtistById(id);
+
+            if (artistOpt.isEmpty()){
+                logger.warn("Artist not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Artist not found"));
+            }
+            ArtistMessages.Artist artistProto = ArtistMapper.toProtobuf(artistOpt.get());
+            ArtistMessages.GetArtistByIdResponse getByIdResponse = ArtistMessages.GetArtistByIdResponse.newBuilder()
+                    .setArtist(artistProto)
+                    .build();
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+        } catch (Exception e) {
+            logger.error("Error getting artist by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: "+ e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/artist/GetArtistHandler.java

@@ -0,0 +1,48 @@
+package com.mediamanager.service.delegate.handler.artist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.ArtistMapper;
+import com.mediamanager.model.Artist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ArtistMessages;
+import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+
+@Action("artist.getAll")
+public class GetArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetArtistHandler.class);
+
+    private final ArtistService artistService;
+
+    public GetArtistHandler(ArtistService artistService){this.artistService = artistService;}
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            List<Artist> artists = artistService.getAllArtists();
+            ArtistMessages.GetArtistsResponse.Builder responseBuilder = ArtistMessages.GetArtistsResponse.newBuilder();
+
+            for (Artist artist : artists) {
+                ArtistMessages.Artist artistProto = ArtistMapper.toProtobuf(artist);
+                responseBuilder.addArtists(artistProto);
+            }
+            ArtistMessages.GetArtistsResponse getArtistsResponse = responseBuilder.build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getArtistsResponse.toByteString());
+
+        }catch (Exception e){
+            logger.error("Error getting artists", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/artist/UpdateArtistHandler.java

@@ -0,0 +1,65 @@
+package com.mediamanager.service.delegate.handler.artist;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.ArtistMapper;
+import com.mediamanager.model.Artist;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.ArtistMessages;
+import com.mediamanager.service.artist.ArtistService;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action("artist.update")
+public class UpdateArtistHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateArtistHandler.class);
+    private final ArtistService artistService;
+
+    public UpdateArtistHandler(ArtistService artistService) {
+        this.artistService = artistService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload) throws InvalidProtocolBufferException {
+        try{
+            ArtistMessages.UpdateArtistRequest updateRequest =
+                    ArtistMessages.UpdateArtistRequest.parseFrom(requestPayload);
+
+            int id = updateRequest.getId();
+            String newName = updateRequest.getName();
+
+            Optional<Artist> artistOpt = artistService.updateArtist(id, newName);
+
+            if(artistOpt.isEmpty()){
+                logger.warn("Artist not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Artist not found"));
+            }
+
+            ArtistMessages.Artist artistProto = ArtistMapper.toProtobuf(artistOpt.get());
+
+            ArtistMessages.UpdateArtistResponse updateResponse = ArtistMessages.UpdateArtistResponse.newBuilder()
+                    .setArtist(artistProto)
+                    .build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(updateResponse.toByteString());
+
+        } catch (IllegalArgumentException e){
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+        } catch (Exception e) {
+            logger.error("Error updating artist", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/genre/CreateGenreHandler.java

@@ -0,0 +1,62 @@
+package com.mediamanager.service.delegate.handler.genre;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.GenreMapper;
+import com.mediamanager.model.Genre;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.GenreMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.genre.GenreService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("genre.create")
+public class CreateGenreHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(CreateGenreHandler.class);
+
+    private final GenreService genreService;
+
+    public CreateGenreHandler(GenreService genreService) {
+        this.genreService = genreService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+        try {
+            // 1. Parse protobuf request
+            GenreMessages.CreateGenreRequest createRequest =
+                    GenreMessages.CreateGenreRequest.parseFrom(requestPayload);
+
+            // 2. Chama service (lógica de negócio)
+            Genre genre = genreService.createGenre(createRequest.getName());
+
+            // 3. Converte entity para protobuf
+            GenreMessages.Genre genreProto = GenreMapper.toProtobuf(genre);
+
+            // 4. Cria response protobuf
+            GenreMessages.CreateGenreResponse createResponse =
+                    GenreMessages.CreateGenreResponse.newBuilder()
+                            .setGenre(genreProto)
+                            .build();
+
+            // 5. Retorna
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(createResponse.toByteString());
+
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+
+        } catch (Exception e) {
+            logger.error("Error creating genre", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/genre/DeleteGenreHandler.java

@@ -0,0 +1,72 @@
+package com.mediamanager.service.delegate.handler.genre;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.GenreMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.genre.GenreService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+@Action("genre.delete")
+public class DeleteGenreHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(DeleteGenreHandler.class);
+
+    private final GenreService genreService;
+
+    public DeleteGenreHandler(GenreService genreService) {
+        this.genreService = genreService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+        try {
+            // 1. Parse protobuf request
+            GenreMessages.DeleteGenreRequest deleteRequest =
+                    GenreMessages.DeleteGenreRequest.parseFrom(requestPayload);
+
+            int id = deleteRequest.getId();
+
+            // 2. Deleta via service
+            boolean success = genreService.deleteGenre(id);
+
+            // 3. Cria response
+            GenreMessages.DeleteGenreResponse deleteResponse;
+
+            if (success) {
+                deleteResponse = GenreMessages.DeleteGenreResponse.newBuilder()
+                        .setSuccess(true)
+                        .setMessage("Genre deleted successfully")
+                        .build();
+
+                return TransportProtocol.Response.newBuilder()
+                        .setPayload(deleteResponse.toByteString());
+            } else {
+                deleteResponse = GenreMessages.DeleteGenreResponse.newBuilder()
+                        .setSuccess(false)
+                        .setMessage("Genre not found")
+                        .build();
+
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(deleteResponse.toByteString());
+            }
+
+        } catch (Exception e) {
+            logger.error("Error deleting genre", e);
+
+            GenreMessages.DeleteGenreResponse deleteResponse =
+                    GenreMessages.DeleteGenreResponse.newBuilder()
+                            .setSuccess(false)
+                            .setMessage("Error: " + e.getMessage())
+                            .build();
+
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(deleteResponse.toByteString());
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/genre/GetGenreByIdHandler.java

@@ -0,0 +1,66 @@
+package com.mediamanager.service.delegate.handler.genre;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.GenreMapper;
+import com.mediamanager.model.Genre;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.GenreMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.genre.GenreService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action("genre.getById")
+public class GetGenreByIdHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetGenreByIdHandler.class);
+
+    private final GenreService genreService;
+
+    public GetGenreByIdHandler(GenreService genreService) {
+        this.genreService = genreService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+        try {
+            // 1. Parse protobuf request
+            GenreMessages.GetGenreByIdRequest getByIdRequest =
+                    GenreMessages.GetGenreByIdRequest.parseFrom(requestPayload);
+
+            int id = getByIdRequest.getId();
+
+            // 2. Busca via service
+            Optional<Genre> genreOpt = genreService.getGenreById(id);
+
+            if (genreOpt.isEmpty()) {
+                logger.warn("Genre not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Genre not found"));
+            }
+
+            // 3. Converte para protobuf
+            GenreMessages.Genre genreProto = GenreMapper.toProtobuf(genreOpt.get());
+
+            GenreMessages.GetGenreByIdResponse getByIdResponse =
+                    GenreMessages.GetGenreByIdResponse.newBuilder()
+                            .setGenre(genreProto)
+                            .build();
+
+            // 4. Retorna
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getByIdResponse.toByteString());
+
+        } catch (Exception e) {
+            logger.error("Error getting genre by ID", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/genre/GetGenreHandler.java

@@ -0,0 +1,56 @@
+package com.mediamanager.service.delegate.handler.genre;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.GenreMapper;
+import com.mediamanager.model.Genre;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.GenreMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.genre.GenreService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+@Action("genre.getAll")
+public class GetGenreHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(GetGenreHandler.class);
+
+    private final GenreService genreService;
+
+    public GetGenreHandler(GenreService genreService) {
+        this.genreService = genreService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+        try {
+            // 1. Busca todos os genres via service
+            List<Genre> genres = genreService.getAllGenres();
+
+            // 2. Converte cada Genre para protobuf
+            GenreMessages.GetGenresResponse.Builder responseBuilder =
+                    GenreMessages.GetGenresResponse.newBuilder();
+
+            for (Genre genre : genres) {
+                GenreMessages.Genre genreProto = GenreMapper.toProtobuf(genre);
+                responseBuilder.addGenres(genreProto);
+            }
+
+            GenreMessages.GetGenresResponse getGenresResponse = responseBuilder.build();
+
+            // 3. Retorna
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(getGenresResponse.toByteString());
+
+        } catch (Exception e) {
+            logger.error("Error getting genres", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/delegate/handler/genre/UpdateGenreHandler.java

@@ -0,0 +1,73 @@
+package com.mediamanager.service.delegate.handler.genre;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.mediamanager.mapper.GenreMapper;
+import com.mediamanager.model.Genre;
+import com.mediamanager.protocol.TransportProtocol;
+import com.mediamanager.protocol.messages.GenreMessages;
+import com.mediamanager.service.delegate.ActionHandler;
+import com.mediamanager.service.delegate.annotation.Action;
+import com.mediamanager.service.genre.GenreService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Optional;
+
+@Action("genre.update")
+public class UpdateGenreHandler implements ActionHandler {
+    private static final Logger logger = LogManager.getLogger(UpdateGenreHandler.class);
+
+    private final GenreService genreService;
+
+    public UpdateGenreHandler(GenreService genreService) {
+        this.genreService = genreService;
+    }
+
+    @Override
+    public TransportProtocol.Response.Builder handle(ByteString requestPayload)
+            throws InvalidProtocolBufferException {
+        try {
+            // 1. Parse protobuf request
+            GenreMessages.UpdateGenreRequest updateRequest =
+                    GenreMessages.UpdateGenreRequest.parseFrom(requestPayload);
+
+            int id = updateRequest.getId();
+            String newName = updateRequest.getName();
+
+            // 2. Atualiza via service
+            Optional<Genre> genreOpt = genreService.updateGenre(id, newName);
+
+            if (genreOpt.isEmpty()) {
+                logger.warn("Genre not found with ID: {}", id);
+                return TransportProtocol.Response.newBuilder()
+                        .setStatusCode(404)
+                        .setPayload(ByteString.copyFromUtf8("Genre not found"));
+            }
+
+            // 3. Converte para protobuf
+            GenreMessages.Genre genreProto = GenreMapper.toProtobuf(genreOpt.get());
+
+            GenreMessages.UpdateGenreResponse updateResponse =
+                    GenreMessages.UpdateGenreResponse.newBuilder()
+                            .setGenre(genreProto)
+                            .build();
+
+            // 4. Retorna
+            return TransportProtocol.Response.newBuilder()
+                    .setPayload(updateResponse.toByteString());
+
+        } catch (IllegalArgumentException e) {
+            logger.error("Validation error", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(400)
+                    .setPayload(ByteString.copyFromUtf8("Validation error: " + e.getMessage()));
+
+        } catch (Exception e) {
+            logger.error("Error updating genre", e);
+            return TransportProtocol.Response.newBuilder()
+                    .setStatusCode(500)
+                    .setPayload(ByteString.copyFromUtf8("Error: " + e.getMessage()));
+        }
+    }
+}

src/main/java/com/mediamanager/service/genre/GenreService.java

@@ -0,0 +1,88 @@
+package com.mediamanager.service.genre;
+
+import com.mediamanager.model.Genre;
+import com.mediamanager.repository.GenreRepository;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Service para lógica de negócio relacionada a Genre
+ */
+public class GenreService {
+    private static final Logger logger = LogManager.getLogger(GenreService.class);
+
+    private final GenreRepository genreRepository;
+
+    public GenreService(GenreRepository genreRepository) {
+        this.genreRepository = genreRepository;
+    }
+
+    /**
+     * Cria um novo genre
+     */
+    public Genre createGenre(String name) {
+        logger.info("Creating genre: {}", name);
+
+        // Aqui poderia ter validações de negócio
+        if (name == null || name.trim().isEmpty()) {
+            throw new IllegalArgumentException("Genre name cannot be empty");
+        }
+
+        Genre genre = new Genre();
+        genre.setName(name.trim());
+
+        return genreRepository.save(genre);
+    }
+
+    /**
+     * Busca todos os genres
+     */
+    public List<Genre> getAllGenres() {
+        logger.info("Getting all genres");
+        return genreRepository.findAll();
+    }
+
+    /**
+     * Busca genre por ID
+     */
+    public Optional<Genre> getGenreById(Integer id) {
+        logger.info("Getting genre by ID: {}", id);
+        return genreRepository.findById(id);
+    }
+
+    /**
+     * Atualiza um genre existente
+     */
+    public Optional<Genre> updateGenre(Integer id, String name) {
+        logger.info("Updating genre ID {}: {}", id, name);
+
+        // Validação
+        if (name == null || name.trim().isEmpty()) {
+            throw new IllegalArgumentException("Genre name cannot be empty");
+        }
+
+        Optional<Genre> existingGenre = genreRepository.findById(id);
+
+        if (existingGenre.isEmpty()) {
+            logger.warn("Genre not found with ID: {}", id);
+            return Optional.empty();
+        }
+
+        Genre genre = existingGenre.get();
+        genre.setName(name.trim());
+
+        Genre updated = genreRepository.update(genre);
+        return Optional.of(updated);
+    }
+
+    /**
+     * Deleta um genre por ID
+     */
+    public boolean deleteGenre(Integer id) {
+        logger.info("Deleting genre ID: {}", id);
+        return genreRepository.deleteById(id);
+    }
+}

src/main/java/com/mediamanager/service/ipc/IPCManager.java

@@ -125,7 +125,7 @@ public class IPCManager {
         }
 
 
-        logger.info("Closing IPC connection...");
+          logger.info("Closing IPC connection...");
 
         running.set(false);
         if (serverChannel != null && serverChannel.isOpen()) {
@@ -185,7 +185,7 @@ public class IPCManager {
                     // Nenhum cliente conectado no momento
                     // Dorme por um curto período antes de verificar novamente
                     // Isso evita consumir CPU desnecessariamente em um loop vazio
-                    Thread.sleep(100); // 100 milissegundos
+                    Thread.sleep(1); // 1 milissegundos
                 }
 
             } catch (InterruptedException e) {
@@ -223,9 +223,16 @@ public class IPCManager {
             logger.debug("Client {} handler thread started", clientId);
 
             try {
-                TransportProtocol.Request request = readRequest(channel);
+                // LOOP: processa múltiplas requests na mesma conexão
+                while (channel.isOpen()) {
+                    TransportProtocol.Request request = readRequest(channel);
+
+                    if (request == null) {
+                        // Cliente desconectou gracefully
+                        logger.info("Client {} disconnected (end of stream)", clientId);
+                        break;
+                    }
 
-                if (request != null) {
                     logger.info("Client {} sent request {}", clientId, request.getRequestId());
 
                     // Processa usando o DelegateActionManager
@@ -233,17 +240,29 @@ public class IPCManager {
 
                     // Envia resposta de volta
                     writeResponse(channel, response);
-
                     logger.info("Client {} response sent", clientId);
-                } else {
-                    logger.warn("Client {} sent null message", clientId);
+
+                    // Verifica se é comando CLOSE
+                    String connectionHeader = response.getHeadersOrDefault("Connection", "");
+                    if ("close".equals(connectionHeader)) {
+                        logger.info("Client {} requested connection close", clientId);
+                        break; // Sai do loop e fecha
+                    }
                 }
 
+            } catch (IOException e) {
+                if (channel.isOpen()) {
+                    logger.error("IO error handling client {}", clientId, e);
+                } else {
+                    logger.debug("Client {} connection closed by peer", clientId);
+                }
             } catch (Exception e) {
-                logger.error("Error handling client {}", clientId, e);
+                logger.error("Unexpected error handling client {}", clientId, e);
             } finally {
                 try {
-                    channel.close();
+                    if (channel.isOpen()) {
+                        channel.close();
+                    }
                     logger.debug("Client {} channel closed", clientId);
                 } catch (IOException e) {
                     logger.error("Error closing client {} channel", clientId, e);

src/main/proto/artist.proto

@@ -0,0 +1,53 @@
+syntax = "proto3";
+
+option java_package = "com.mediamanager.protocol.messages";
+option java_outer_classname = "ArtistMessages";
+
+package mediamanager.messages;
+
+message Artist {
+  int32 id = 1;
+  string name = 2;
+}
+
+message CreateArtistRequest {
+  string name = 1;
+}
+
+message CreateArtistResponse {
+  Artist artist = 1;
+}
+
+message GetArtistsRequest {
+
+}
+
+message GetArtistsResponse {
+  repeated Artist artists = 1;
+}
+
+message GetArtistByIdRequest {
+  int32 id = 1;
+}
+
+message GetArtistByIdResponse {
+  Artist artist = 1;
+}
+
+message UpdateArtistRequest {
+  int32 id = 1;
+  string name = 2;  // Novo nome
+}
+
+message UpdateArtistResponse {
+  Artist Artist = 1;
+}
+
+message DeleteArtistRequest {
+  int32 id = 1;
+}
+
+message DeleteArtistResponse {
+  bool success = 1;
+  string message = 2;
+}

src/main/proto/genre.proto

@@ -0,0 +1,53 @@
+syntax = "proto3";
+
+option java_package = "com.mediamanager.protocol.messages";
+option java_outer_classname = "GenreMessages";
+
+package mediamanager.messages;
+
+message Genre {
+  int32 id = 1;
+  string name = 2;
+}
+
+message CreateGenreRequest {
+  string name = 1;
+}
+
+message CreateGenreResponse {
+  Genre genre = 1;
+}
+
+message GetGenresRequest {
+
+}
+
+message GetGenresResponse {
+  repeated Genre genres = 1;
+}
+
+message GetGenreByIdRequest {
+  int32 id = 1;
+}
+
+message GetGenreByIdResponse {
+  Genre genre = 1;
+}
+
+message UpdateGenreRequest {
+  int32 id = 1;
+  string name = 2;  // Novo nome
+}
+
+message UpdateGenreResponse {
+  Genre genre = 1;  // Genre atualizado
+}
+
+message DeleteGenreRequest {
+  int32 id = 1;
+}
+
+message DeleteGenreResponse {
+  bool success = 1;
+  string message = 2;
+}

src/main/proto/test.proto

@@ -0,0 +1,30 @@
+syntax = "proto3";
+
+option java_package = "com.mediamanager.protocol";
+option java_outer_classname = "TestProtocol";
+
+package mediamanager.test;
+
+message EchoCommand {
+  string message = 1;
+}
+
+message EchoResponse {
+  string message = 1;
+  int64 server_timestamp = 2;
+}
+
+message HeartbeatCommand {
+  int64 client_timestamp = 1;
+}
+
+message HeartbeatResponse {
+  int64 client_timestamp = 1;
+  int64 server_timestamp = 2;
+}
+message CloseCommand {
+  // Vazio - apenas sinaliza fechamento
+}
+message CloseResponse {
+  string message = 1;
+}

src/main/resources/config.properties.example

@@ -21,7 +21,8 @@ hibernate.format_sql=true
 ipc.pipe.name=mediamanager-pipe
 ipc.pipe.path=/tmp/mediamanager
 ipc.buffer.size=8192
-
-ipc.socket.path=/tmp/mediamanager
 runtype=local
+ipc.socket.path=/tmp/mediamanager
+
+
 

src/main/resources/log4j2.xml

@@ -18,40 +18,17 @@
     </Appenders>
     
     <Loggers>
-        <Logger name="com.mediamanager" level="debug" additivity="false">
+        <Logger name="com.mediamanager" level="INFO" additivity="false">
             <AppenderRef ref="Console"/>
             <AppenderRef ref="FileAppender"/>
         </Logger>
         
-        <Logger name="org.hibernate" level="info" additivity="false">
-            <AppenderRef ref="Console"/>
-            <AppenderRef ref="FileAppender"/>
-        </Logger>
-
-        <Logger name="io.zonky.test" level="INFO" additivity="false">
-            <AppenderRef ref="Console"/>
-            <AppenderRef ref="FileAppender"/>
-        </Logger>
-
-        <!-- PostgreSQL JDBC Driver -->
-        <Logger name="org.postgresql" level="WARN" additivity="false">
-            <AppenderRef ref="Console"/>
-            <AppenderRef ref="FileAppender"/>
-        </Logger>
-
-        <!-- Processo do PostgreSQL embedded -->
-        <Logger name="org.postgresql.embedded" level="INFO" additivity="false">
-            <AppenderRef ref="Console"/>
-            <AppenderRef ref="FileAppender"/>
-        </Logger>
-
-        <!-- HikariCP Connection Pool -->
-        <Logger name="com.zaxxer.hikari" level="INFO" additivity="false">
+        <Logger name="org.hibernate" level="INFO" additivity="false">
             <AppenderRef ref="Console"/>
             <AppenderRef ref="FileAppender"/>
         </Logger>
         
-        <Root level="info">
+        <Root level="INFO">
             <AppenderRef ref="Console"/>
             <AppenderRef ref="FileAppender"/>
         </Root>