feat: add save feature

Reviewed-on: http://95.38.179.159:3000/Amirmahdi/back-meditation/pulls/2

app/Http/Controllers/CommentController.php

@@ -0,0 +1,147 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use Illuminate\Http\Request;
+
+class CommentController extends Controller
+{
+      /**
+     * Add comment to any model
+     */
+    public function addComment(Request $request, $type, $id)
+    {
+        $request->validate([
+            'content' => 'required|string|max:1000',
+        ]);
+
+        $model = $this->getModel($type, $id);
+        $this->checkAccess($model);
+        
+        $comment = $model->comments()->create([
+            'user_id' => auth()->id(),
+            'content' => $request->content,
+        ]);
+        
+        return response()->json([
+            'message' => 'Comment added successfully',
+            'comment' => $comment->load('user'),
+        ], 201);
+    }
+    
+    /**
+     * Get all comments for a model
+     */
+    public function getComments($type, $id)
+    {
+        $model = $this->getModel($type, $id);
+        $this->checkAccess($model);
+        
+        $comments = $model->comments()
+            ->with('user')
+            ->latest()
+            ->paginate(20);
+        
+        return response()->json($comments);
+    }
+    
+    /**
+     * Update comment
+     */
+    public function updateComment(Request $request, $type, $id, $commentId)
+    {
+        $request->validate([
+            'content' => 'required|string|max:1000',
+        ]);
+        
+        $comment = Comment::where('id', $commentId)
+            ->where('user_id', auth()->id())
+            ->where('commentable_id', $id)
+            ->where('commentable_type', $this->getModelClass($type))
+            ->firstOrFail();
+        
+        $comment->update([
+            'content' => $request->content,
+        ]);
+        
+        return response()->json([
+            'message' => 'Comment updated successfully',
+            'comment' => $comment->load('user'),
+        ]);
+    }
+    
+    /**
+     * Delete comment
+     */
+    public function deleteComment($type, $id, $commentId)
+    {
+        $comment = Comment::where('id', $commentId)
+            ->where('user_id', auth()->id())
+            ->where('commentable_id', $id)
+            ->where('commentable_type', $this->getModelClass($type))
+            ->firstOrFail();
+        
+        $comment->delete();
+        
+        return response()->json([
+            'message' => 'Comment deleted successfully',
+        ]);
+    }
+    
+    /**
+     * Get most commented items
+     */
+    public function mostCommented($type)
+    {
+        $modelClass = $this->getModelClass($type);
+        $userId = auth()->id();
+        
+        $items = $modelClass::with(['image', 'user'])
+            ->withCount('comments')
+            ->where(function($query) use ($modelClass, $userId) {
+                if (property_exists($modelClass, 'type')) {
+                    $query->where('type', 'public')
+                          ->orWhere(function($q) use ($userId) {
+                              $q->where('type', 'private')
+                                ->where('user_id', $userId);
+                          });
+                }
+            })
+            ->orderBy('comments_count', 'desc')
+            ->limit(10)
+            ->get();
+        
+        return response()->json($items);
+    }
+    
+    private function getModel($type, $id)
+    {
+        $modelClass = $this->getModelClass($type);
+        $model = $modelClass::findOrFail($id);
+        
+        return $model;
+    }
+    
+    private function getModelClass($type)
+    {
+        $models = [
+            'music' => \App\Models\Music::class,
+            'media' => \App\Models\Media::class,
+        ];
+        
+        if (!isset($models[$type])) {
+            abort(404, 'Invalid model type');
+        }
+        
+        return $models[$type];
+    }
+    
+    private function checkAccess($model)
+    {
+        if (property_exists($model, 'type') && $model->type === 'private') {
+            if (auth()->id() !== $model->user_id) {
+                abort(403, 'You do not have access to this item');
+            }
+        }
+    }
+}

app/Http/Controllers/MediaController.php

@@ -319,9 +319,18 @@ public function filters(Request $request)
     ]);
 }
 
-    public function show($id)
-    {
-     $media = Media::with(['image', 'category', 'myNote', 'tags' ,'comments'])
+   public function show($id)
+{
+    $media = Media::with([
+            'image', 
+            'category', 
+            'myNote', 
+            'tags',
+            'comments' => function($query) {
+                $query->with('user')->latest()->limit(10);
+            },
+            'ratings'
+        ])
         ->where('id', $id)
         ->where(function($query) {
             $query->where('visibility', 'public')
@@ -329,7 +338,16 @@ public function show($id)
         })
         ->firstOrFail();
 
-         return response()->json([
+    // Get user's specific comment
+    $userComment = $media->userComment();
+    
+    // Get paginated comments
+    $comments = $media->comments()
+        ->with('user')
+        ->latest()
+        ->paginate(15);
+
+    return response()->json([
         'id' => $media->id,
         'title' => $media->title,
         'caption' => $media->caption,
@@ -340,18 +358,28 @@ public function show($id)
         'visibility' => $media->visibility,
         'created_at' => $media->created_at,
         'updated_at' => $media->updated_at,
+        'is_premium' => $media->is_premium,
         'image' => $media->image,
         'category' => $media->category,
         'tags' => $media->tags,
         'myNote' => $media->myNote,
         'is_saved' => $media->is_saved,
-        'is_premium' => $media->is_premium,
-        'comments' => $media->comments,
-        'average_rating' => $media->average_rating,
-        'your_rating' => $media->user_rating,
-        'comments_count' => $media->comments()->count(),
+        'statistics' => [
+            'average_rating' => $media->average_rating,
+            'total_ratings' => $media->ratings_count,
+            'total_comments' => $media->comments_count,
+            'rating_distribution' => $media->rating_distribution,
+        ],
+        'user_interaction' => [
+            'has_rated' => $media->has_user_rated,
+            'user_rating' => $media->user_rating,
+            'has_commented' => $media->has_user_commented,
+            'user_comment' => $media->user_comment,
+            'user_comment_id' => $media->user_comment_id,
+        ],
+        'comments' => $comments,
     ]);
-    }
+}
 public function rate(Request $request, $mediaId)
 {
     $request->validate([

app/Http/Controllers/MusicController.php

@@ -10,6 +10,25 @@
 class MusicController extends Controller
 {
 
+    // Add this new method to your MusicController
+    public function getAllMusic()
+    {
+        $userId = auth()->id();
+
+        $music = Music::with(['image', 'playlist'])
+            ->where('type', 'public')
+            ->orWhere(function($query) use ($userId) {
+                $query->where('type', 'private')
+                    ->where('user_id', $userId);
+            })
+            ->orderBy('created_at', 'desc')
+            ->get();
+
+        // Return as array directly (not wrapped in 'data' object)
+        // to match what your old Flutter app expects
+        return response()->json($music);
+    }
+
     public function index()
     {
         $userId = auth()->id();
@@ -104,11 +123,11 @@ public function store(Request $request)
             $data = $request->validate([
                 'title' => 'required|string|max:255',
                 'artist' => 'nullable|string|max:255',
-                'file' => 'required|mimes:mp3,wav,ogg|max:20971520',
+                'file' => 'required|mimes:mp3,wav,ogg,flac|max:20971520',
                 'type' => 'nullable|in:public,private',
                 'image_id' => 'nullable|exists:images,id',
                 'playlist_id' => 'nullable|exists:music_playlists,id',
-                'duration' => 'nullable|string|regex:/^(?:\d+:)?[0-5]?\d:[0-5]\d$/', // validates mm:ss or hh:mm:ss
+                'duration' => 'nullable|integer|min:1', // validates mm:ss or hh:mm:ss
             ]);
 
             // Handle file upload
@@ -188,10 +207,10 @@ public function update(Request $request, $id)
                 'title' => 'nullable|string|max:255',
                 'artist' => 'nullable|string|max:255',
                 'type' => 'nullable|in:public,private',
-                'file' => 'nullable|mimes:mp3,wav,ogg|max:10240',
+                'file' => 'nullable|mimes:mp3,wav,ogg,flac|max:20971520',
                 'image_id' => 'nullable|exists:images,id',
                 'playlist_id' => 'nullable|exists:music_playlists,id',
-                'duration' => 'nullable|string|regex:/^(?:\d+:)?[0-5]?\d:[0-5]\d$/',
+                'duration' => 'nullable|integer|min:1',
                 'order' => 'nullable|integer',
                 'is_active' => 'nullable|boolean',
             ]);
@@ -223,11 +242,19 @@ public function update(Request $request, $id)
 
 
     // ✅ Get all public + user private music
-    public function show($id)
+public function show($id)
 {
     $userId = auth()->id();
 
-    $music = Music::with(['image', 'playlist', 'tags'])
+    $music = Music::with([
+            'image', 
+            'playlist', 
+            'tags',
+            'comments' => function($query) {
+                $query->with('user')->latest()->limit(10);
+            },
+            'ratings'
+        ])
         ->where(function($query) use ($userId) {
             $query->where('type', 'public')
                   ->orWhere(function($q) use ($userId) {
@@ -237,7 +264,32 @@ public function show($id)
         })
         ->findOrFail($id);
     
-    return response()->json($music);
+    // Get user's specific comment
+    $userComment = $music->userComment();
+    
+    // Get paginated comments for the response
+    $comments = $music->comments()
+        ->with('user')
+        ->latest()
+        ->paginate(15);
+    
+    return response()->json([
+        'music' => $music,
+        'statistics' => [
+            'average_rating' => $music->average_rating,
+            'total_ratings' => $music->ratings_count,
+            'total_comments' => $music->comments_count,
+            'rating_distribution' => $music->rating_distribution,
+        ],
+        'user_interaction' => [
+            'has_rated' => $music->has_user_rated,
+            'user_rating' => $music->user_rating,
+            'has_commented' => $music->has_user_commented,
+            'user_comment' => $music->user_comment,
+            'user_comment_id' => $music->user_comment_id,
+        ],
+        'comments' => $comments,
+    ]);
 }
 
     // ✅ Delete music

app/Http/Controllers/MusicPlaylistController.php

@@ -8,40 +8,52 @@
 
 class MusicPlaylistController extends Controller
 {
-    public function index(Request $request)
-    {
-        $query = MusicPlaylist::with(['category', 'image']);
+   public function index(Request $request)
+        {
+            $query = MusicPlaylist::with(['category', 'subcategory', 'image']);
             
-        if ($request->has('category_id')) {
-            $query->where('category_id', $request->category_id);
+            if ($request->has('category_id')) {
+                $query->where('category_id', $request->category_id)->whereNull('subcategory_id');
+            }
+            
+            if ($request->has('subcategory_id')) {
+                $query->where('subcategory_id', $request->subcategory_id);
+            }
+            
+            $playlists = $query->where('is_active', true)->orderBy('order')->get();
+            
+            return response()->json($playlists);
         }
             
-        $playlists = $query->where('is_active', true)->orderBy('order')->get();
-        
-        return response()->json($playlists);
-    }
-    
     public function store(Request $request)
-    {
-        $data = $request->validate([
-            'category_id' => 'required|exists:music_categories,id',
-            'name' => 'required|string|max:255',
-            'description' => 'nullable|string',
-            'image_id' => 'nullable|exists:images,id',
-            'order' => 'nullable|integer',
-            'is_active' => 'nullable|boolean',
-        ]);
-        
-        $data['slug'] = Str::slug($data['name']);
-        
-        $playlist = MusicPlaylist::create($data);
+{
+    $data = $request->validate([
+        'category_id' => 'nullable|exists:music_categories,id',
+        'subcategory_id' => 'nullable|exists:music_subcategories,id',
+        'name' => 'required|string|max:255',
+        'description' => 'nullable|string',
+        'image_id' => 'nullable|exists:images,id',
+        'order' => 'nullable|integer',
+        'is_active' => 'nullable|boolean',
+    ]);
     
+    // Ensure either category_id or subcategory_id is provided
+    if (!$data['category_id'] && !$data['subcategory_id']) {
         return response()->json([
-            'message' => 'Playlist created successfully',
-            'playlist' => $playlist->load(['category', 'image'])
-        ], 201);
+            'message' => 'Either category_id or subcategory_id is required'
+        ], 422);
     }
     
+    $data['slug'] = Str::slug($data['name']);
+    
+    $playlist = MusicPlaylist::create($data);
+    
+    return response()->json([
+        'message' => 'Playlist created successfully',
+        'playlist' => $playlist->load(['category', 'subcategory', 'image'])
+    ], 201);
+}
+    
     public function show($id)
     {
         $playlist = MusicPlaylist::with([

app/Http/Controllers/MusicSubcategoryController.php

@@ -0,0 +1,117 @@
+<?php
+
+namespace App\Http\Controllers;
+
+
+use App\Models\MusicSubcategory;
+use App\Models\MusicCategory;
+use Illuminate\Http\Request;
+use Illuminate\Support\Str;
+
+class MusicSubcategoryController extends Controller
+{
+   public function index(Request $request)
+    {
+        $query = MusicSubcategory::with(['category', 'image', 'playlists' => function($q) {
+            $q->where('is_active', true)->orderBy('order');
+        }]);
+        
+        if ($request->has('category_id')) {
+            $query->where('category_id', $request->category_id);
+        }
+        
+        $subcategories = $query->where('is_active', true)->orderBy('order')->get();
+        
+        return response()->json($subcategories);
+    }
+    
+    public function store(Request $request)
+    {
+        try {
+            $data = $request->validate([
+                'category_id' => 'required|exists:music_categories,id',
+                'name' => 'required|string|max:255',
+                'description' => 'nullable|string',
+                'image_id' => 'nullable|exists:images,id',
+                'order' => 'nullable|integer',
+                'is_active' => 'nullable|boolean',
+            ]);
+            
+            $slug = Str::slug($data['name']);
+            
+            // Check for duplicate in same category
+            $existing = MusicSubcategory::where('category_id', $data['category_id'])
+                ->where('slug', $slug)
+                ->first();
+            
+            if ($existing) {
+                return response()->json([
+                    'message' => 'A subcategory with this name already exists in this category',
+                    'errors' => ['name' => ['The subcategory name must be unique within this category.']]
+                ], 422);
+            }
+            
+            $data['slug'] = $slug;
+            $subcategory = MusicSubcategory::create($data);
+            
+            return response()->json([
+                'message' => 'Subcategory created successfully',
+                'subcategory' => $subcategory->load(['category', 'image'])
+            ], 201);
+            
+        } catch (\Exception $e) {
+            return response()->json([
+                'message' => 'An error occurred while creating the subcategory',
+                'error' => $e->getMessage()
+            ], 500);
+        }
+    }
+    
+    public function show($id)
+    {
+        $subcategory = MusicSubcategory::with([
+            'category',
+            'image',
+            'playlists' => function($q) {
+                $q->with(['image', 'musics' => function($q2) {
+                    $q2->where('is_active', true)->with('image')->orderBy('order');
+                }])->where('is_active', true)->orderBy('order');
+            }
+        ])->findOrFail($id);
+        
+        return response()->json($subcategory);
+    }
+    
+    public function update(Request $request, $id)
+    {
+        $subcategory = MusicSubcategory::findOrFail($id);
+        
+        $data = $request->validate([
+            'category_id' => 'sometimes|exists:music_categories,id',
+            'name' => 'sometimes|string|max:255',
+            'description' => 'nullable|string',
+            'image_id' => 'nullable|exists:images,id',
+            'order' => 'nullable|integer',
+            'is_active' => 'nullable|boolean',
+        ]);
+        
+        if (isset($data['name'])) {
+            $data['slug'] = Str::slug($data['name']);
+        }
+        
+        $subcategory->update($data);
+        
+        return response()->json([
+            'message' => 'Subcategory updated successfully',
+            'subcategory' => $subcategory->load(['category', 'image'])
+        ]);
+    }
+    
+    public function destroy($id)
+    {
+        $subcategory = MusicSubcategory::findOrFail($id);
+        $subcategory->delete();
+        
+        return response()->json(['message' => 'Subcategory deleted successfully']);
+    }
+}

app/Http/Controllers/RatingController.php

@@ -0,0 +1,151 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use Illuminate\Http\Request;
+
+class RatingController extends Controller
+{
+      /**
+     * Add or update rating for any model
+     * 
+     * @param Request $request
+     * @param string $type (music, media, etc.)
+     * @param int $id
+     */
+    public function rate(Request $request, $type, $id)
+    {
+        $request->validate([
+            'stars' => 'required|integer|min:1|max:5',
+        ]);
+
+        $model = $this->getModel($type, $id);
+        $this->checkAccess($model);
+        
+        $rating = $model->ratings()->updateOrCreate(
+            ['user_id' => auth()->id()],
+            ['stars' => $request->stars]
+        );
+        
+        return response()->json([
+            'message' => 'Rating submitted successfully',
+            'rating' => $rating,
+            'average_rating' => $model->fresh()->average_rating,
+            'user_rating' => $rating->stars,
+            'total_ratings' => $model->fresh()->ratings_count,
+        ]);
+    }
+    
+    /**
+     * Get user's rating for a model
+     */
+    public function getUserRating($type, $id)
+    {
+        $model = $this->getModel($type, $id);
+        
+        $rating = $model->ratings()
+            ->where('user_id', auth()->id())
+            ->first();
+        
+        return response()->json([
+            'rating' => $rating ? $rating->stars : null,
+        ]);
+    }
+    
+    /**
+     * Delete user's rating
+     */
+    public function deleteRating($type, $id)
+    {
+        $model = $this->getModel($type, $id);
+        
+        $deleted = $model->ratings()
+            ->where('user_id', auth()->id())
+            ->delete();
+        
+        return response()->json([
+            'message' => $deleted ? 'Rating deleted successfully' : 'No rating found',
+        ]);
+    }
+    
+    /**
+     * Get all ratings for a model
+     */
+    public function getRatings($type, $id)
+    {
+        $model = $this->getModel($type, $id);
+        $this->checkAccess($model);
+        
+        $ratings = $model->ratings()
+            ->with('user')
+            ->latest()
+            ->paginate(20);
+        
+        return response()->json([
+            'average' => $model->average_rating,
+            'total' => $model->ratings_count,
+            'ratings' => $ratings,
+        ]);
+    }
+    
+    /**
+     * Get top rated items
+     */
+    public function topRated($type)
+    {
+        $modelClass = $this->getModelClass($type);
+        $userId = auth()->id();
+        
+        $items = $modelClass::with(['image', 'user'])
+            ->withAvg('ratings', 'stars')
+            ->where(function($query) use ($modelClass, $userId) {
+                if (method_exists($modelClass, 'isAccessible')) {
+                    // Use model-specific access logic
+                } elseif (property_exists($modelClass, 'type')) {
+                    $query->where('type', 'public')
+                          ->orWhere(function($q) use ($userId) {
+                              $q->where('type', 'private')
+                                ->where('user_id', $userId);
+                          });
+                }
+            })
+            ->having('ratings_avg_stars', '>', 0)
+            ->orderBy('ratings_avg_stars', 'desc')
+            ->limit(10)
+            ->get();
+        
+        return response()->json($items);
+    }
+    
+    private function getModel($type, $id)
+    {
+        $modelClass = $this->getModelClass($type);
+        $model = $modelClass::findOrFail($id);
+        
+        return $model;
+    }
+    
+    private function getModelClass($type)
+    {
+        $models = [
+            'music' => \App\Models\Music::class,
+            'media' => \App\Models\Media::class,
+        ];
+        
+        if (!isset($models[$type])) {
+            abort(404, 'Invalid model type');
+        }
+        
+        return $models[$type];
+    }
+    
+    private function checkAccess($model)
+    {
+        // Check if model has 'type' property (public/private)
+        if (property_exists($model, 'type') && $model->type === 'private') {
+            if (auth()->id() !== $model->user_id) {
+                abort(403, 'You do not have access to this item');
+            }
+        }
+    }
+}

app/Http/Controllers/SaveController.php

@@ -0,0 +1,225 @@
+<?php
+// app/Http/Controllers/SaveController.php
+namespace App\Http\Controllers;
+
+use Illuminate\Http\Request;
+use App\Models\SavedItem;
+
+class SaveController extends Controller
+{
+    /**
+     * Save an item (music, media, breathing template, etc.)
+     */
+    public function save(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,breathing-template',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        $result = $model->addSave();
+        
+        return response()->json([
+            'message' => 'Item saved successfully',
+            'is_saved' => true,
+            'saved_count' => $model->saved_count
+        ]);
+    }
+    
+    /**
+     * Unsave an item
+     */
+    public function unsave(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,breathing-template',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        $result = $model->removeSave();
+        
+        return response()->json([
+            'message' => 'Item removed from saved',
+            'is_saved' => false,
+            'saved_count' => $model->saved_count
+        ]);
+    }
+    
+    /**
+     * Toggle save status
+     */
+    public function toggleSave(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,breathing-template',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        $result = $model->toggleSaveStatus();
+        
+        return response()->json([
+            'message' => $result ? 'Item saved successfully' : 'Item removed from saved',
+            'is_saved' => $model->is_saved,
+            'saved_count' => $model->saved_count
+        ]);
+    }
+    
+    /**
+     * Get all saved items for the authenticated user
+     */
+     public function mySavedItems(Request $request)
+    {
+        $type = $request->get('type'); // Optional filter by type
+        
+        $query = SavedItem::with('saveable')
+            ->where('user_id', auth()->id());
+        
+        if ($type) {
+            $modelClass = $this->getModelClass($type);
+            $query->where('saveable_type', $modelClass);
+        }
+        
+        $savedItems = $query->latest()->paginate(20);
+        
+        return response()->json([
+            'data' => $savedItems,
+            'total' => $savedItems->total(),
+            'types' => [
+                'music' => 'App\\Models\\Music',
+                'media' => 'App\\Models\\Media',
+                'breathing-template' => 'App\\Models\\BreathingTemplate',
+            ]
+        ]);
+    }
+    /**
+     * Check if specific item is saved by user
+     */
+    public function checkSaved(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,breathing-template',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        return response()->json([
+            'is_saved' => $model->is_saved,
+            'saved_count' => $model->saved_count
+        ]);
+    }
+    
+    private function getModel($type, $id)
+    {
+        $modelClass = $this->getModelClass($type);
+        return $modelClass::find($id);
+    }
+    
+    private function getModelClass($type)
+    {
+        $models = [
+            'music' => \App\Models\Music::class,
+            'media' => \App\Models\Media::class,
+            'breathing-template' => \App\Models\BreathingTemplate::class,
+        ];
+        
+        return $models[$type] ?? null;
+    }
+}
+
+
+
+
+
+//    public function mySavedItems(Request $request)
+//     {
+//         $type = $request->get('type');
+        
+//         $query = SavedItem::with('saveable')
+//             ->where('user_id', auth()->id());
+        
+//         if ($type) {
+//             $modelClass = $this->getModelClass($type);
+//             $query->where('saveable_type', $modelClass);
+//         }
+        
+//         $savedItems = $query->latest()->paginate(20);
+        
+//         // Transform the response to include formatted data
+//         $transformedItems = $savedItems->map(function ($savedItem) {
+//             $item = $savedItem->saveable;
+            
+//             if (!$item) return null;
+            
+//             $baseData = [
+//                 'saved_id' => $savedItem->id,
+//                 'saved_at' => $savedItem->created_at,
+//                 'type' => class_basename($savedItem->saveable_type),
+//             ];
+            
+//             // Add type-specific data
+//             if ($item instanceof \App\Models\Music) {
+//                 return array_merge($baseData, [
+//                     'id' => $item->id,
+//                     'title' => $item->title,
+//                     'artist' => $item->artist,
+//                     'duration' => $item->duration_formatted ?? $item->duration,
+//                     'image_url' => $item->image_url,
+//                     'is_saved' => true,
+//                 ]);
+//             } elseif ($item instanceof \App\Models\Media) {
+//                 return array_merge($baseData, [
+//                     'id' => $item->id,
+//                     'title' => $item->title,
+//                     'caption' => $item->caption,
+//                     'type' => $item->type,
+//                     'duration' => $item->duration,
+//                     'image_url' => $item->image->url ?? null,
+//                     'is_saved' => true,
+//                 ]);
+//             } elseif ($item instanceof \App\Models\BreathingTemplate) {
+//                 return array_merge($baseData, [
+//                     'id' => $item->id,
+//                     'name' => $item->name,
+//                     'description' => $item->description,
+//                     'duration' => $item->duration,
+//                     'inhale' => $item->inhale,
+//                     'exhale' => $item->exhale,
+//                     'breath_hold' => $item->breath_hold,
+//                     'image_url' => $item->image_url,
+//                     'is_saved' => true,
+//                 ]);
+//             }
+            
+//             return $baseData;
+//         })->filter();

app/Models/BreathingTemplate.php

@@ -3,16 +3,18 @@
 namespace App\Models;
 
 use Illuminate\Database\Eloquent\Model;
+use App\Traits\HasSaves;
 
 class BreathingTemplate extends Model
 {
+     use HasSaves;
     protected $fillable = ['user_id', 'name', 'inhale', 'exhale', 'breath_hold' , 'duration' , 'description','image_id' , 'source'];
 
     public function user()
     {
         return $this->belongsTo(User::class);
     }
-    protected $appends = ['image_url'];
+    protected $appends = ['image_url', 'is_saved','saved_count'];
 
     public function getImageUrlAttribute()
     {

app/Models/Comment.php

@@ -8,17 +8,44 @@ class Comment extends Model
 {
       protected $fillable = [
         'user_id',
-        'media_id',
+        'commentable_id',
+        'commentable_type',
         'content',
     ];
-
+    protected $with = ['user'];
     public function user()
     {
         return $this->belongsTo(User::class);
     }
 
+        public function commentable()
+    {
+        return $this->morphTo();
+    }
+    
+    // For backward compatibility with Media
     public function media()
     {
-        return $this->belongsTo(Media::class);
+        return $this->belongsTo(Media::class, 'commentable_id')->where('commentable_type', Media::class);
     }
+    
+    // For Music
+    public function music()
+    {
+        return $this->belongsTo(Music::class, 'commentable_id')->where('commentable_type', Music::class);
+    }
+
+     // Check if comment belongs to current user
+    public function getIsOwnerAttribute()
+    {
+        return auth()->check() && $this->user_id === auth()->id();
+    }
+    
+    // Add timestamps formatted
+    public function getFormattedCreatedAtAttribute()
+    {
+        return $this->created_at->diffForHumans();
+    }
+    
+    protected $appends = ['is_owner', 'formatted_created_at'];
 }

app/Models/Media.php

@@ -3,9 +3,13 @@
 namespace App\Models;
 
 use Illuminate\Database\Eloquent\Model;
+use App\Traits\HasRatings;
+use App\Traits\HasComments;
+use App\Traits\HasSaves;
 
 class Media extends Model
 {
+     use HasRatings, HasComments,HasSaves;
   protected $fillable = [
         'user_id',
         'image_id',
@@ -19,10 +23,18 @@ class Media extends Model
         'visibility',
         'is_premium'
     ];
-protected $appends = [
-    'average_rating',
-    'user_rating',
-];
+    protected $appends = [
+        'average_rating',
+        'user_rating',
+        'ratings_count',
+        'comments_count',
+        'has_user_commented',    
+        'user_comment',         
+        'user_comment_id',      
+        'has_user_rated',   
+        'is_saved', 
+        'saved_count'      
+    ];
     public function image()
     {
         return $this->belongsTo(Image::class);
@@ -68,27 +80,4 @@ public function getIsSavedAttribute()
             ->where('user_id', auth()->id())
             ->exists();
     }
-public function ratings()
-{
-    return $this->hasMany(Rating::class);
-}
-
-public function getAverageRatingAttribute()
-{
-    return round($this->ratings()->avg('stars'), 1);
-}
-
-public function getUserRatingAttribute()
-{
-    if (!auth()->check()) return null;
-
-    return $this->ratings()
-        ->where('user_id', auth()->id())
-        ->value('stars');
-}
-
-public function comments()
-{
-    return $this->hasMany(Comment::class);
-}
 }

app/Models/Music.php

@@ -7,9 +7,14 @@
 use Illuminate\Database\Eloquent\Relations\BelongsTo;  // ← Add this
 use Illuminate\Database\Eloquent\Relations\BelongsToMany;  // ← Add this
 use Illuminate\Database\Eloquent\Relations\HasMany;    // ← Add this
+use Illuminate\Database\Eloquent\Relations\MorphMany;    // ← Add this
+use App\Traits\HasRatings;
+use App\Traits\HasComments;
+use App\Traits\HasSaves;
+
 class Music extends Model
 {   
-     use HasFactory;
+     use HasFactory, HasRatings, HasComments , HasSaves;
      protected $table = 'music';
     
 
@@ -18,7 +23,7 @@ class Music extends Model
         'playlist_id', 'image_id', 'duration', 'order', 'is_active'
     ];
  protected $casts = [
-        'duration' => 'string',
+        'duration' => 'integer',
         'order' => 'integer',
         'is_active' => 'boolean',
     ];
@@ -39,8 +44,19 @@ public function tags(): BelongsToMany
         return $this->belongsToMany(Tag::class, 'music_tags');
     }
     
-    protected $appends = ['url', 'image_url'];
-    // Accessor for full URL
+    protected $appends = ['url',
+    'image_url' , 
+    'average_rating',
+    'user_rating', 
+    'comments_count' , 
+    'has_user_commented',  
+    'user_comment',         
+    'user_comment_id',         
+    'has_user_rated' ,
+    'is_saved', 
+    'saved_count'         
+    ];
+
     public function getUrlAttribute()
     {
         return asset('storage/' . $this->file_path);

app/Models/MusicCategory.php

@@ -23,6 +23,21 @@ public function playlists(): HasMany
         return $this->hasMany(MusicPlaylist::class, 'category_id');
     }
 
+    public function subcategories(): HasMany
+    {
+        return $this->hasMany(MusicSubcategory::class, 'category_id');
+    }
+       // All playlists (including those in subcategories)
+    public function allPlaylists()
+    {
+        $playlists = collect($this->playlists);
+        
+        foreach ($this->subcategories as $subcategory) {
+            $playlists = $playlists->merge($subcategory->playlists);
+        }
+        
+        return $playlists;
+    }
     public function image(): BelongsTo
     {
         return $this->belongsTo(Image::class);
@@ -32,4 +47,18 @@ public function getActivePlaylistsAttribute()
     {
         return $this->playlists()->where('is_active', true)->get();
     }
+
+      // Total music count across all playlists and subcategories
+    public function getTotalMusicCountAttribute()
+    {
+        $count = $this->playlists->sum(function($playlist) {
+            return $playlist->musics->count();
+        });
+        
+        foreach ($this->subcategories as $subcategory) {
+            $count += $subcategory->total_music_count;
+        }
+        
+        return $count;
+    }
 }

app/Models/MusicPlaylist.php

@@ -10,7 +10,7 @@ class MusicPlaylist extends Model
     protected $table = 'music_playlists';
     
     protected $fillable = [
-        'category_id', 'name', 'slug', 'description', 'image_id', 'order', 'is_active'
+        'category_id', 'subcategory_id','name', 'slug', 'description', 'image_id', 'order', 'is_active'
     ];
     
     protected $casts = [
@@ -23,6 +23,12 @@ public function category(): BelongsTo
         return $this->belongsTo(MusicCategory::class, 'category_id');
     }
     
+     public function subcategory(): BelongsTo
+    {
+        return $this->belongsTo(MusicSubcategory::class, 'subcategory_id');
+    }
+    
+    
     public function musics(): HasMany
     {
         return $this->hasMany(Music::class, 'playlist_id');

app/Models/MusicSubcategory.php

@@ -0,0 +1,85 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+class MusicSubcategory extends Model
+{
+        protected $table = 'music_subcategories';
+    
+    protected $fillable = [
+        'category_id', 'name', 'slug', 'description', 'image_id', 'order', 'is_active'
+    ];
+    
+    protected $casts = [
+        'is_active' => 'boolean',
+        'order' => 'integer',
+    ];
+    
+    public function category(): BelongsTo
+    {
+        return $this->belongsTo(MusicCategory::class, 'category_id');
+    }
+    
+    public function playlists(): HasMany
+    {
+        return $this->hasMany(MusicPlaylist::class, 'subcategory_id');
+    }
+    
+    public function image(): BelongsTo
+    {
+        return $this->belongsTo(Image::class);
+    }
+    
+    public function getActivePlaylistsAttribute()
+    {
+        return $this->playlists()->where('is_active', true)->orderBy('order')->get();
+    }
+    
+    // Get total music count across all playlists in this subcategory
+    public function getTotalMusicCountAttribute()
+    {
+        return $this->playlists()
+            ->withCount('musics')
+            ->get()
+            ->sum('musics_count');
+    }
+    
+    // Get total duration across all music in this subcategory
+    public function getTotalDurationAttribute()
+    {
+        $totalSeconds = 0;
+        foreach ($this->playlists as $playlist) {
+            foreach ($playlist->musics as $music) {
+                $totalSeconds += $this->durationToSeconds($music->duration);
+            }
+        }
+        return $this->secondsToDuration($totalSeconds);
+    }
+    
+    private function durationToSeconds($duration)
+    {
+        if (!$duration) return 0;
+        $parts = explode(':', $duration);
+        if (count($parts) === 2) {
+            return (int)$parts[0] * 60 + (int)$parts[1];
+        } elseif (count($parts) === 3) {
+            return (int)$parts[0] * 3600 + (int)$parts[1] * 60 + (int)$parts[2];
+        }
+        return 0;
+    }
+    
+    private function secondsToDuration($seconds)
+    {
+        $hours = floor($seconds / 3600);
+        $minutes = floor(($seconds % 3600) / 60);
+        $secs = $seconds % 60;
+        
+        if ($hours > 0) {
+            return sprintf("%d:%02d:%02d", $hours, $minutes, $secs);
+        }
+        return sprintf("%d:%02d", $minutes, $secs);
+    }
+}

app/Models/Rating.php

@@ -8,17 +8,30 @@ class Rating extends Model
 {
     protected $fillable = [
         'user_id',
-        'media_id',
+        'rateable_id',
+        'rateable_type',
         'stars',
     ];
 
-    public function media()
+    public function rateable()
     {
-        return $this->belongsTo(Media::class);
+        return $this->morphTo();
     }
 
     public function user()
     {
         return $this->belongsTo(User::class);
     }
+    
+    // For backward compatibility with Media
+    public function media()
+    {
+        return $this->belongsTo(Media::class, 'rateable_id')->where('rateable_type', Media::class);
+    }
+    
+    // For Music
+    public function music()
+    {
+        return $this->belongsTo(Music::class, 'rateable_id')->where('rateable_type', Music::class);
+    }
 }

app/Models/SavedItem.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+class SavedItem extends Model
+{
+    protected $table = 'saved_items';
+    
+    protected $fillable = [
+        'user_id',
+        'saveable_id',
+        'saveable_type',
+    ];
+    
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+    
+    public function saveable(): MorphTo
+    {
+        return $this->morphTo();
+    }
+    
+    // Helper to get saved items by type
+    public static function getSavedItemsForUser($userId, $type = null)
+    {
+        $query = self::with('saveable')->where('user_id', $userId);
+        
+        if ($type) {
+            $query->where('saveable_type', $type);
+        }
+        
+        return $query->latest()->get();
+    }
+    
+    // Check if user has saved specific item
+    public static function isSavedByUser($userId, $saveableId, $saveableType)
+    {
+        return self::where([
+            'user_id' => $userId,
+            'saveable_id' => $saveableId,
+            'saveable_type' => $saveableType,
+        ])->exists();
+    }
+}

app/Traits/HasComments.php

@@ -0,0 +1,67 @@
+<?php
+// app/Traits/HasComments.php
+namespace App\Traits;
+
+use App\Models\Comment;
+
+trait HasComments
+{
+    public function comments()
+    {
+        return $this->morphMany(Comment::class, 'commentable');
+    }
+ // Get user's specific comment
+    public function userComment()
+    {
+        if (!auth()->check()) return null;
+        
+        return $this->comments()
+            ->where('user_id', auth()->id())
+            ->first();
+    }
+    
+    // Check if user has commented
+    public function getHasUserCommentedAttribute()
+    {
+        return !is_null($this->userComment());
+    }
+    
+    // Get user's comment content
+    public function getUserCommentAttribute()
+    {
+        $comment = $this->userComment();
+        return $comment ? $comment->content : null;
+    }
+    
+    // Get user's comment id
+    public function getUserCommentIdAttribute()
+    {
+        $comment = $this->userComment();
+        return $comment ? $comment->id : null;
+    }
+    
+    // Get latest comments with user info
+    public function getLatestCommentsAttribute()
+    {
+        return $this->comments()
+            ->with('user')
+            ->latest()
+            ->limit(10)
+            ->get();
+    }
+    
+    // Get paginated comments
+    public function getPaginatedComments($perPage = 15)
+    {
+        return $this->comments()
+            ->with('user')
+            ->latest()
+            ->paginate($perPage);
+    }
+
+
+    public function getCommentsCountAttribute()
+    {
+        return $this->comments()->count();
+    }
+}

app/Traits/HasRatings.php

@@ -0,0 +1,57 @@
+<?php
+// app/Traits/HasRatings.php
+namespace App\Traits;
+
+use App\Models\Rating;
+
+trait HasRatings
+{
+    public function ratings()
+    {
+        return $this->morphMany(Rating::class, 'rateable');
+    }
+
+    public function getAverageRatingAttribute()
+    {
+        return round($this->ratings()->avg('stars'), 1);
+    }
+
+    public function getUserRatingAttribute()
+    {
+        if (!auth()->check()) return null;
+        
+        return $this->ratings()
+            ->where('user_id', auth()->id())
+            ->value('stars');
+    }
+   // Get user's rating object
+    public function userRating()
+    {
+        if (!auth()->check()) return null;
+        
+        return $this->ratings()
+            ->where('user_id', auth()->id())
+            ->first();
+    }
+    
+    // Check if user has rated
+    public function getHasUserRatedAttribute()
+    {
+        return !is_null($this->userRating());
+    }
+
+    public function getRatingsCountAttribute()
+    {
+        return $this->ratings()->count();
+    }
+    
+    // Get rating distribution
+    public function getRatingDistributionAttribute()
+    {
+        $distribution = [];
+        for ($i = 1; $i <= 5; $i++) {
+            $distribution[$i] = $this->ratings()->where('stars', $i)->count();
+        }
+        return $distribution;
+    }
+}

app/Traits/HasSaves.php

@@ -0,0 +1,59 @@
+<?php
+// app/Traits/HasSaves.php
+namespace App\Traits;
+
+use App\Models\SavedItem;
+use Illuminate\Database\Eloquent\Relations\MorphMany;
+
+trait HasSaves
+{
+    public function saves()
+    {
+        return $this->morphMany(SavedItem::class, 'saveable');
+    }
+    
+    public function getIsSavedAttribute()
+    {
+        if (!auth()->check()) return false;
+        
+        return $this->saves()
+            ->where('user_id', auth()->id())
+            ->exists();
+    }
+    
+    public function getSavedCountAttribute()
+    {
+        return $this->saves()->count();
+    }
+    
+    public function toggleSaveStatus()
+    {
+        if ($this->getIsSavedAttribute()) {
+            return $this->removeSave();
+        } else {
+            return $this->addSave();
+        }
+    }
+    
+    public function addSave()
+    {
+        if ($this->getIsSavedAttribute()) return false;
+        
+        return SavedItem::create([
+            'user_id' => auth()->id(),
+            'saveable_id' => $this->id,
+            'saveable_type' => get_class($this),
+        ]);
+    }
+    
+    public function removeSave()
+    {
+        if (!$this->getIsSavedAttribute()) return false;
+        
+        return SavedItem::where([
+            'user_id' => auth()->id(),
+            'saveable_id' => $this->id,
+            'saveable_type' => get_class($this),
+        ])->delete();
+    }
+}

database/migrations/2026_05_20_061423_make_comments_polymorphic.php

@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('comments', function (Blueprint $table) {
+            $table->dropForeign(['media_id']);
+            $table->dropColumn('media_id');
+            
+            // Add polymorphic columns
+            $table->morphs('commentable');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('comments', function (Blueprint $table) {
+            $table->dropMorphs('commentable');
+            $table->foreignId('media_id')->constrained()->onDelete('cascade');
+        });
+    }
+};

database/migrations/2026_05_20_070900_make_ratings_polymorphic.php

@@ -0,0 +1,65 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::dropIfExists('ratings');
+
+        Schema::create('ratings', function (Blueprint $table) {
+            $table->id();
+
+            $table->foreignId('user_id')
+                ->constrained()
+                ->cascadeOnDelete();
+
+            // polymorphic relation
+            $table->morphs('rateable');
+
+            $table->tinyInteger('stars'); // 1-5
+
+            $table->timestamps();
+
+            // one rating per user per item
+            $table->unique([
+                'user_id',
+                'rateable_id',
+                'rateable_type'
+            ], 'ratings_user_rateable_unique');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('ratings');
+
+        // optional: rollback old structure (if you still need it)
+        Schema::create('ratings', function (Blueprint $table) {
+            $table->id();
+
+            $table->foreignId('user_id')
+                ->constrained()
+                ->cascadeOnDelete();
+
+            $table->foreignId('media_id')
+                ->constrained()
+                ->cascadeOnDelete();
+
+            $table->tinyInteger('stars');
+
+            $table->timestamps();
+
+            $table->unique(['user_id', 'media_id']);
+        });
+    }
+};

database/migrations/2026_05_21_105404_create_music_subcategories_table.php

@@ -0,0 +1,36 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('music_subcategories', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('category_id')->constrained('music_categories')->onDelete('cascade');
+            $table->string('name');
+            $table->string('slug')->unique();
+            $table->text('description')->nullable();
+            $table->foreignId('image_id')->nullable()->constrained('images')->onDelete('set null');
+            $table->integer('order')->default(0);
+            $table->boolean('is_active')->default(true);
+            $table->timestamps();
+            
+            $table->index(['category_id', 'order']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('music_subcategories');
+    }
+};

database/migrations/2026_05_21_105523_add_subcategory_to_playlists.php

@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('music_playlists', function (Blueprint $table) {
+           $table->foreignId('subcategory_id')->nullable()->after('category_id')
+                  ->constrained('music_subcategories')->onDelete('cascade');
+            // Make category_id nullable since playlist can belong to subcategory
+            $table->foreignId('category_id')->nullable()->change();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('music_playlists', function (Blueprint $table) {
+           $table->dropForeign(['subcategory_id']);
+            $table->dropColumn('subcategory_id');
+            $table->foreignId('category_id')->nullable(false)->change();
+        });
+    }
+};

database/migrations/2026_05_22_175608_change_duration_to_integer_in_music_table.php

@@ -0,0 +1,28 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::table('music', function (Blueprint $table) {
+            $table->integer('duration')->nullable()->change();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('music', function (Blueprint $table) {
+            $table->string('duration')->nullable()->change();
+        });
+    }
+};

database/migrations/2026_05_22_200854_create_saved_items_table.php

@@ -0,0 +1,31 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('saved_items', function (Blueprint $table) {
+           $table->id();
+            $table->foreignId('user_id')->constrained()->onDelete('cascade');
+            $table->morphs('saveable'); // saveable_id + saveable_type
+            $table->timestamps();
+            
+            $table->unique(['user_id', 'saveable_id', 'saveable_type']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('saved_items');
+    }
+};

routes/api.php

@@ -17,6 +17,10 @@
 use App\Http\Controllers\MediaController;
 use App\Http\Controllers\MusicCategoryController;
 use App\Http\Controllers\MusicPlaylistController;
+use App\Http\Controllers\RatingController;
+use App\Http\Controllers\CommentController;
+use App\Http\Controllers\MusicSubcategoryController;
+use App\Http\Controllers\SaveController;
 
 Route::get('/test-hash', function() {
     $plain = 'amnk1380';
@@ -163,10 +167,48 @@
     Route::apiResource('music-playlists', MusicPlaylistController::class);
     Route::get('playlists/by-category/{categoryId}', [MusicPlaylistController::class, 'index']);
 
+    // Subcategory routes
+    Route::apiResource('music-subcategories', MusicSubcategoryController::class);
+    Route::get('subcategories/by-category/{categoryId}', [MusicSubcategoryController::class, 'index']);
+
+
+    // Music Routes - Add this line before your other routes
+    Route::get('music/all', [MusicController::class, 'getAllMusic']); // For old app compatibility
+
     // Music
     Route::get('music/playlist/{playlistId}', [MusicController::class, 'getMusicByPlaylist']);
     Route::post('music/{musicId}/add-to-playlist', [MusicController::class, 'addToPlaylist']);
     Route::delete('music/{musicId}/remove-from-playlist', [MusicController::class, 'removeFromPlaylist']);
     Route::post('music/update-order', [MusicController::class, 'updateOrder']);
     Route::apiResource('music', MusicController::class);
+
+    
+
+    // Generic Rating Routes (works for both music and media)
+    Route::prefix('ratings')->group(function () {
+    Route::post('{type}/{id}', [RatingController::class, 'rate']);
+    Route::get('{type}/{id}/user', [RatingController::class, 'getUserRating']);
+    Route::delete('{type}/{id}', [RatingController::class, 'deleteRating']);
+    Route::get('{type}/{id}', [RatingController::class, 'getRatings']);
+    Route::get('top/{type}', [RatingController::class, 'topRated']);
+    });
+
+    // Generic Comment Routes (works for both music and media)
+    Route::prefix('comments')->group(function () {
+        Route::post('{type}/{id}', [CommentController::class, 'addComment']);
+        Route::get('{type}/{id}', [CommentController::class, 'getComments']);
+        Route::put('{type}/{id}/{commentId}', [CommentController::class, 'updateComment']);
+        Route::delete('{type}/{id}/{commentId}', [CommentController::class, 'deleteComment']);
+        Route::get('most/{type}', [CommentController::class, 'mostCommented']);
+    });
+
+
+    // Save routes (works for all models)
+    Route::prefix('saves')->group(function () {
+        Route::post('/save', [SaveController::class, 'save']);
+        Route::post('/unsave', [SaveController::class, 'unsave']);
+        Route::post('/toggle', [SaveController::class, 'toggleSave']);
+        Route::get('/my-saved', [SaveController::class, 'mySavedItems']);
+        Route::post('/check', [SaveController::class, 'checkSaved']);
+    });
   });