feat: media play

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

app/Http/Controllers/CategoryController.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Category;
+use Illuminate\Http\Request;
+
+class CategoryController extends Controller
+{
+    public function index(Request $request)
+    {
+        $query = Category::query()->withCount('subcategories');
+
+        if ($request->boolean('with_subcategories')) {
+            $query->with('subcategories');
+        }
+
+        return response()->json(
+            $query->orderBy('name')->get()
+        );
+    }
+
+    public function store(Request $request)
+    {
+        $data = $request->validate([
+            'name' => 'required|string|max:255|unique:categories,name',
+        ]);
+
+        $category = Category::create($data);
+
+        return response()->json([
+            'message' => 'Category created successfully',
+            'category' => $category,
+        ], 201);
+    }
+
+    public function show($id)
+    {
+        $category = Category::with('subcategories')->withCount('subcategories')->findOrFail($id);
+
+        return response()->json($category);
+    }
+
+    public function update(Request $request, $id)
+    {
+        $category = Category::findOrFail($id);
+
+        $data = $request->validate([
+            'name' => 'required|string|max:255|unique:categories,name,' . $category->id,
+        ]);
+
+        $category->update($data);
+
+        return response()->json([
+            'message' => 'Category updated successfully',
+            'category' => $category,
+        ]);
+    }
+
+    public function destroy($id)
+    {
+        $category = Category::findOrFail($id);
+        $category->delete();
+
+        return response()->json(['message' => 'Category deleted successfully']);
+    }
+}

app/Http/Controllers/CommentController.php

@@ -127,10 +127,11 @@ private function getModelClass($type)
         $models = [
             'music' => \App\Models\Music::class,
             'media' => \App\Models\Media::class,
+            'playlist' => \App\Models\MusicPlaylist::class, 
         ];
         
         if (!isset($models[$type])) {
-            abort(404, 'Invalid model type');
+            abort(404, 'Invalid model type. Supported types: music, media, playlist');
         }
         
         return $models[$type];

app/Http/Controllers/LikeController.php

@@ -0,0 +1,236 @@
+<?php
+
+namespace App\Http\Controllers;
+use App\Models\Like;
+use Illuminate\Http\Request;
+
+class LikeController extends Controller
+{
+     /**
+     * Like an item (music or media)
+     */
+    public function like(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,playlist',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        $result = $model->addLike();
+        
+        return response()->json([
+            'message' => 'Item liked successfully',
+            'is_liked' => true,
+            'likes_count' => $model->likes_count
+        ]);
+    }
+    
+    /**
+     * Unlike an item
+     */
+    public function unlike(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,playlist',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        $result = $model->removeLike();
+        
+        return response()->json([
+            'message' => 'Item unliked successfully',
+            'is_liked' => false,
+            'likes_count' => $model->likes_count
+        ]);
+    }
+    
+    /**
+     * Toggle like status
+     */
+    public function toggleLike(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,playlist',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        $result = $model->toggleLike();
+        
+        return response()->json([
+            'message' => $result ? 'Item liked successfully' : 'Item unliked successfully',
+            'is_liked' => $model->is_liked,
+            'likes_count' => $model->likes_count
+        ]);
+    }
+    
+    /**
+     * Get all liked items for the authenticated user
+     */
+    public function myLikedItems(Request $request)
+    {
+        $type = $request->get('type'); // Optional filter by type (music or media)
+        
+        $query = Like::with('likeable')
+            ->where('user_id', auth()->id());
+        
+        if ($type) {
+            $modelClass = $this->getModelClass($type);
+            $query->where('likeable_type', $modelClass);
+        }
+        
+        $likedItems = $query->latest()->paginate(20);
+
+          return response()->json([
+            'data' => $likedItems,
+            'total' => $likedItems->total(),
+            'types' => [
+                'music' => 'App\\Models\\Music',
+                'media' => 'App\\Models\\Media',
+                'playlist' => 'App\\Models\\MusicPlaylist',
+            ]
+        ]);
+        // Transform the response
+        // $transformedItems = $likedItems->map(function ($likeItem) {
+        //     $item = $likeItem->likeable;
+            
+        //     if (!$item) return null;
+            
+        //     $baseData = [
+        //         'like_id' => $likeItem->id,
+        //         'liked_at' => $likeItem->created_at,
+        //         'type' => class_basename($likeItem->likeable_type),
+        //         'is_liked' => true,
+        //     ];
+            
+        //     // 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,
+        //             'likes_count' => $item->likes_count,
+        //             'type_display' => 'music'
+        //         ]);
+        //     } elseif ($item instanceof \App\Models\Media) {
+        //         return array_merge($baseData, [
+        //             'id' => $item->id,
+        //             'title' => $item->title,
+        //             'caption' => $item->caption,
+        //             'media_type' => $item->type,
+        //             'duration' => $item->duration,
+        //             'image_url' => $item->image->url ?? null,
+        //             'likes_count' => $item->likes_count,
+        //             'type_display' => 'media'
+        //         ]);
+        //     }
+            
+        //     return $baseData;
+        // })->filter();
+        
+        // return response()->json([
+        //     'data' => $transformedItems,
+        //     'total' => $likedItems->total(),
+        //     'current_page' => $likedItems->currentPage(),
+        //     'last_page' => $likedItems->lastPage(),
+        //     'per_page' => $likedItems->perPage(),
+        // ]);
+    }
+    
+    /**
+     * Check if specific item is liked by user
+     */
+    public function checkLiked(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,playlist',
+            'id' => 'required|integer',
+        ]);
+        
+        $model = $this->getModel($request->type, $request->id);
+        
+        if (!$model) {
+            return response()->json([
+                'message' => 'Item not found'
+            ], 404);
+        }
+        
+        return response()->json([
+            'is_liked' => $model->is_liked,
+            'likes_count' => $model->likes_count
+        ]);
+    }
+    
+    /**
+     * Get top liked items
+     */
+    public function topLiked(Request $request)
+    {
+        $type = $request->get('type', 'music'); // Default to music
+        $limit = $request->get('limit', 10);
+        
+        $modelClass = $this->getModelClass($type);
+        
+        $items = $modelClass::with(['image'])
+            ->withCount('likes')
+            ->where(function($query) use ($modelClass) {
+                if (property_exists($modelClass, 'type')) {
+                    $query->where('type', 'public');
+                }
+                if (property_exists($modelClass, 'visibility')) {
+                    $query->where('visibility', 'public');
+                }
+            })
+            ->orderBy('likes_count', 'desc')
+            ->limit($limit)
+            ->get();
+        
+        return response()->json([
+            'data' => $items,
+            'type' => $type,
+            'total' => $items->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,
+            'playlist' => \App\Models\MusicPlaylist::class,
+        ];
+
+        return $models[$type] ?? null;
+    }
+}

app/Http/Controllers/MediaController.php

@@ -3,7 +3,9 @@
 namespace App\Http\Controllers;
 
 use App\Models\Media;
+use App\Models\MediaPlay;
 use App\Models\Category;
+use App\Models\SubCategory;
 use App\Models\Tag;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Http\Request;
@@ -18,8 +20,10 @@ public function store(Request $request)
             'title' => 'required|string|max:255',
             'caption' => 'nullable|string',
             'type' => 'required|in:audio,video',
-            'category_id' => 'nullable|exists:categories,id',
+            'category_ids' => 'nullable|array',
-            'category_name' => 'nullable|string|max:255',
+            'category_ids.*' => 'integer|exists:categories,id',
+            'subcategory_ids' => 'nullable|array',
+            'subcategory_ids.*' => 'integer|exists:sub_categories,id',
             'image_id' => 'nullable|exists:images,id',
             'duration' => 'nullable|integer',
             'is_premium' => 'nullable|boolean',
@@ -31,14 +35,6 @@ public function store(Request $request)
              'tags.*' => 'string',
         ]);
 
-         $categoryId = $data['category_id'] ?? null;
-
-        if (!$categoryId && isset($data['category_name'])) {
-            $category = Category::firstOrCreate([
-                'name' => $data['category_name']
-            ]);
-            $categoryId = $category->id;
-        }
         $path = null;
         if ($request->hasFile('file')) {
             $path = $request->file('file')->store('media', 'public');
@@ -52,11 +48,14 @@ public function store(Request $request)
             'file_path' => $path,
             'external_url' => $data['external_url'] ?? null,
             'image_id' => $data['image_id'] ?? null,
-            'category_id' => $categoryId,
             'duration' => $data['duration'] ?? null,
             'visibility' => $data['visibility'] ?? 'public',
             'is_premium'=> $data['is_premium'] ?? false
         ]);
+
+        $media->categories()->sync($data['category_ids'] ?? []);
+        $media->subCategories()->sync($data['subcategory_ids'] ?? []);
+
         if (!empty($data['tags'])) {
             $tagIds = [];
 
@@ -69,12 +68,12 @@ public function store(Request $request)
         }
         return response()->json([
             'message' => 'Media created successfully',
-            'media' => $media->load(['image', 'category' , 'tags']),
+            'media' => $media->load(['image', 'categories', 'subCategories', 'tags']),
         ]);
     }
 public function index(Request $request)
 {
-    $query = Media::with(['image', 'category', 'myNote', 'tags','comments'])
+    $query = Media::with(['image', 'categories', 'subCategories', 'myNote', 'tags','comments'])
         ->where(function ($q) {
             $q->where('visibility', 'public')
               ->orWhere('user_id', auth()->id());
@@ -88,7 +87,16 @@ public function index(Request $request)
 
     if ($request->filled('categories')) {
         $categories = explode(',', $request->categories);
-        $query->whereIn('category_id', $categories);
+        $query->whereHas('categories', function ($q) use ($categories) {
+            $q->whereIn('categories.id', $categories);
+        });
+    }
+
+    if ($request->filled('subcategories')) {
+        $subcategories = explode(',', $request->subcategories);
+        $query->whereHas('subCategories', function ($q) use ($subcategories) {
+            $q->whereIn('sub_categories.id', $subcategories);
+        });
     }
 
     /*
@@ -164,9 +172,12 @@ public function index(Request $request)
 
             $q->where('title', 'LIKE', "%$search%")
               ->orWhere('caption', 'LIKE', "%$search%")
-              ->orWhereHas('category', function ($c) use ($search) {
+              ->orWhereHas('categories', function ($c) use ($search) {
                   $c->where('name', 'LIKE', "%$search%");
               })
+              ->orWhereHas('subCategories', function ($s) use ($search) {
+                  $s->where('name', 'LIKE', "%$search%");
+              })
               ->orWhereHas('tags', function ($t) use ($search) {
                   $t->where('name', 'LIKE', "%$search%");
               });
@@ -266,21 +277,28 @@ public function filters(Request $request)
     |--------------------------------------------------------------------------
     */
 
-    $categories = Category::select(
+    $visibleMedia = function ($q) {
-            'categories.id',
+        $q->where(function ($inner) {
-            'categories.name',
+            $inner->where('media.visibility', 'public')
-            DB::raw('COUNT(media.id) as media_count')
+                  ->orWhere('media.user_id', auth()->id());
-        )
+        });
-        ->leftJoin('media', function ($join) {
+    };
-            $join->on('categories.id', '=', 'media.category_id')
+
-                ->where(function ($q) {
+    $categories = Category::query()
-                    $q->where('media.visibility', 'public')
+        ->withCount(['media as media_count' => $visibleMedia])
-                      ->orWhere('media.user_id', auth()->id());
-                });
-        })
-        ->groupBy('categories.id', 'categories.name')
         ->orderByDesc('media_count')
-        ->get();
+        ->get(['id', 'name']);
+
+    /*
+    |--------------------------------------------------------------------------
+    | 1️⃣.5 Subcategories with media count
+    |--------------------------------------------------------------------------
+    */
+
+    $subcategories = SubCategory::query()
+        ->withCount(['media as media_count' => $visibleMedia])
+        ->orderByDesc('media_count')
+        ->get(['id', 'category_id', 'name']);
 
 
     /*
@@ -314,8 +332,9 @@ public function filters(Request $request)
         ->get();
 
     return response()->json([
-        'categories' => $categories,
+        'categories'    => $categories,
-        'durations'  => $durations,
+        'subcategories' => $subcategories,
+        'durations'     => $durations,
     ]);
 }
 
@@ -323,7 +342,8 @@ public function show($id)
 {
     $media = Media::with([
             'image',
-            'category', 
+            'categories',
+            'subCategories',
             'myNote',
             'tags',
             'comments' => function($query) {
@@ -360,7 +380,8 @@ public function show($id)
         'updated_at' => $media->updated_at,
         'is_premium' => $media->is_premium,
         'image' => $media->image,
-        'category' => $media->category,
+        'categories' => $media->categories,
+        'sub_categories' => $media->subCategories,
         'tags' => $media->tags,
         'myNote' => $media->myNote,
         'is_saved' => $media->is_saved,
@@ -442,9 +463,10 @@ public function update(Request $request, $id)
         'caption' => 'nullable|string',
         'type' => 'nullable|in:audio,video',
 
-        // support both: category_id or category_name
+        'category_ids' => 'nullable|array',
-        'category_id' => 'nullable|exists:categories,id',
+        'category_ids.*' => 'integer|exists:categories,id',
-        'category_name' => 'nullable|string|max:255',
+        'subcategory_ids' => 'nullable|array',
+        'subcategory_ids.*' => 'integer|exists:sub_categories,id',
         'is_premium' => 'nullable|boolean',
         'image_id' => 'nullable|exists:images,id',
         'duration' => 'nullable|integer',
@@ -455,16 +477,6 @@ public function update(Request $request, $id)
         'tags.*' => 'string',
     ]);
 
-    // --- handle auto-create category ---
-    $categoryId = $data['category_id'] ?? $media->category_id;
-
-    if (isset($data['category_name'])) {
-        $category = Category::firstOrCreate([
-            'name' => $data['category_name']
-        ]);
-        $categoryId = $category->id;
-    }
-
     // --- handle file replace ---
     if ($request->hasFile('file')) {
         Storage::disk('public')->delete($media->file_path);
@@ -476,7 +488,6 @@ public function update(Request $request, $id)
         'title' => $data['title'] ?? $media->title,
         'caption' => $data['caption'] ?? $media->caption,
         'type' => $data['type'] ?? $media->type,
-        'category_id' => $categoryId,
         'is_premium' => $data['is_premium'] ?? $media->is_premium,
         'duration' => $data['duration'] ?? $media->duration,
         'external_url' => $data['external_url'] ?? $media->external_url,
@@ -496,6 +507,14 @@ public function update(Request $request, $id)
     // --- update media ---
     $media->update($updateData);
 
+    if (array_key_exists('category_ids', $data)) {
+        $media->categories()->sync($data['category_ids'] ?? []);
+    }
+
+    if (array_key_exists('subcategory_ids', $data)) {
+        $media->subCategories()->sync($data['subcategory_ids'] ?? []);
+    }
+
     if (isset($data['tags'])) {
         $tagIds = [];
 
@@ -509,7 +528,7 @@ public function update(Request $request, $id)
 
     return response()->json([
         'message' => 'Media updated successfully',
-        'media' => $media->load(['image', 'category' , 'tags']),
+        'media' => $media->load(['image', 'categories', 'subCategories', 'tags']),
     ]);
 }
 
@@ -546,7 +565,77 @@ public function toggleSaveMedia($id)
     // GET saved
     public function saved()
     {
-        return auth()->user()->savedMedia()->with(['image','category' , 'myNote' , 'tags'])->get();
+        return auth()->user()->savedMedia()->with(['image','categories', 'subCategories', 'myNote' , 'tags'])->get();
+    }
+
+    // RECORD a play for the current user (feeds popular + recently played).
+    public function recordPlay($id)
+    {
+        $media = Media::where('id', $id)
+            ->where(function ($q) {
+                $q->where('visibility', 'public')->orWhere('user_id', auth()->id());
+            })
+            ->firstOrFail();
+
+        $play = MediaPlay::firstOrNew([
+            'user_id' => auth()->id(),
+            'media_id' => $media->id,
+        ]);
+        $play->play_count = ($play->play_count ?? 0) + 1;
+        $play->last_played_at = now();
+        $play->save();
+
+        return response()->json([
+            'message' => 'Play recorded',
+            'play_count' => $play->play_count,
+            'last_played_at' => $play->last_played_at,
+        ]);
+    }
+
+    // POPULAR media (global), ranked by total play count across all users.
+    public function popular(Request $request)
+    {
+        $limit = (int) $request->input('limit', 20);
+
+        $media = Media::query()
+            ->where(function ($q) {
+                $q->where('visibility', 'public')->orWhere('user_id', auth()->id());
+            })
+            ->withCount('plays as listeners_count')                 // distinct users who played
+            ->withSum('plays as plays_count', 'play_count')         // total plays
+            ->with(['image', 'categories', 'subCategories', 'tags'])
+            ->orderByDesc('plays_count')
+            ->orderByDesc('listeners_count')
+            ->orderByDesc('created_at')
+            ->limit($limit)
+            ->get();
+
+        return response()->json($media);
+    }
+
+    // RECENTLY PLAYED media for the current user, most recent first.
+    public function recentlyPlayed(Request $request)
+    {
+        $limit = (int) $request->input('limit', 20);
+
+        $plays = MediaPlay::where('user_id', auth()->id())
+            ->whereNotNull('last_played_at')
+            ->with(['media' => fn ($q) => $q->with(['image', 'categories', 'subCategories', 'tags'])])
+            ->orderByDesc('last_played_at')
+            ->limit($limit)
+            ->get();
+
+        $media = $plays->map(function ($play) {
+            $media = $play->media;
+            if (!$media) {
+                return null;
+            }
+            $media->last_played_at = $play->last_played_at;
+            $media->play_count = $play->play_count;
+            return $media;
+        })->filter()->values();
+
+        return response()->json($media);
     }
 
 public function storeNote(Request $request, $mediaId)

app/Http/Controllers/MusicCategoryController.php

@@ -82,7 +82,7 @@ public function show($id)
     {
         $category = MusicCategory::with(['image', 'playlists' => function($q) {
             $q->with(['image', 'musics' => function($q2) {
-                $q2->where('is_active', true)->with('image')->orderBy('order');
+                $q2->where('music.is_active', true)->with('image')->orderBy('music_playlist.order');
             }])->where('is_active', true)->orderBy('order');
         }])->findOrFail($id);
         

app/Http/Controllers/MusicController.php

@@ -10,11 +10,30 @@
 class MusicController extends Controller
 {
 
+    // Add this new method to your MusicController
+    public function getAllMusic()
+    {
+        $userId = auth()->id();
+
+        $music = Music::with(['image', 'playlists'])
+            ->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();
 
-        $music = Music::with(['image', 'playlist'])
+        $music = Music::with(['image', 'playlists'])
             ->where('type', 'public')
             ->orWhere(function($query) use ($userId) {
                 $query->where('type', 'private')
@@ -33,10 +52,10 @@ public function getMusicByPlaylist($playlistId)
     {
         $playlist = MusicPlaylist::findOrFail($playlistId);
 
-        $music = Music::where('playlist_id', $playlistId)
+        $music = $playlist->musics()
-            ->where('is_active', true)
+            ->where('music.is_active', true)
             ->with(['image', 'tags'])
-            ->orderBy('order')
+            ->orderBy('music_playlist.order')
             ->get();
 
         return response()->json([
@@ -59,24 +78,30 @@ public function addToPlaylist(Request $request, $musicId)
             'order' => 'nullable|integer',
         ]);
 
-        $music->update([
+        $order = $data['order'] ?? $this->getNextOrderInPlaylist($data['playlist_id']);
-            'playlist_id' => $data['playlist_id'],
+
-            'order' => $data['order'] ?? $music->order,
+        // Add (or update its order) without removing the music from other playlists.
+        $music->playlists()->syncWithoutDetaching([
+            $data['playlist_id'] => ['order' => $order],
         ]);
 
         return response()->json([
             'message' => 'Music added to playlist successfully',
-            'music' => $music->load(['image', 'playlist'])
+            'music' => $music->load(['image', 'playlists'])
         ]);
     }
 
-    public function removeFromPlaylist($musicId)
+    public function removeFromPlaylist(Request $request, $musicId)
     {
         $music = Music::where('id', $musicId)
             ->where('user_id', auth()->id())
             ->firstOrFail();
 
-        $music->update(['playlist_id' => null]);
+        $data = $request->validate([
+            'playlist_id' => 'required|exists:music_playlists,id',
+        ]);
+
+        $music->playlists()->detach($data['playlist_id']);
 
         return response()->json(['message' => 'Music removed from playlist']);
     }
@@ -84,15 +109,18 @@ public function removeFromPlaylist($musicId)
     public function updateOrder(Request $request)
     {
         $data = $request->validate([
+            'playlist_id' => 'required|exists:music_playlists,id',
             'musics' => 'required|array',
             'musics.*.id' => 'required|exists:music,id',
             'musics.*.order' => 'required|integer',
         ]);
 
+        $playlist = MusicPlaylist::findOrFail($data['playlist_id']);
+
         foreach ($data['musics'] as $item) {
-            Music::where('id', $item['id'])
+            $playlist->musics()->updateExistingPivot($item['id'], [
-                ->where('user_id', auth()->id())
+                'order' => $item['order'],
-                ->update(['order' => $item['order']]);
+            ]);
         }
 
         return response()->json(['message' => 'Order updated successfully']);
@@ -104,11 +132,13 @@ 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',
+                'playlist_id' => 'nullable|exists:music_playlists,id', // single (backward compatible)
-                'duration' => 'nullable|string|regex:/^(?:\d+:)?[0-5]?\d:[0-5]\d$/', // validates mm:ss or hh:mm:ss
+                'playlist_ids' => 'nullable|array',                    // multiple
+                'playlist_ids.*' => 'integer|exists:music_playlists,id',
+                'duration' => 'nullable|integer|min:1', // validates mm:ss or hh:mm:ss
             ]);
 
             // Handle file upload
@@ -142,15 +172,26 @@ public function store(Request $request)
                 'file_path' => $path,
                 'type' => $data['type'] ?? 'private',
                 'image_id' => $data['image_id'] ?? null,
-                'playlist_id' => $data['playlist_id'] ?? null,
                 'duration' => $data['duration'] ?? null, // Store as string
-                'order' => $this->getNextOrderInPlaylist($data['playlist_id'] ?? null),
                 'is_active' => true,
             ]);
 
+            // Merge single + multiple playlist inputs into a unique list.
+            $playlistIds = collect($data['playlist_ids'] ?? [])
+                ->push($data['playlist_id'] ?? null)
+                ->filter()
+                ->unique()
+                ->values();
+
+            foreach ($playlistIds as $playlistId) {
+                $music->playlists()->syncWithoutDetaching([
+                    $playlistId => ['order' => $this->getNextOrderInPlaylist($playlistId)],
+                ]);
+            }
+
             return response()->json([
                 'message' => 'Music uploaded successfully',
-                'music' => $music->load(['image', 'playlist', 'tags']),
+                'music' => $music->load(['image', 'playlists', 'tags']),
                 'url' => asset('storage/' . $path),
             ], 201);
             
@@ -174,7 +215,10 @@ private function getNextOrderInPlaylist($playlistId)
             return 0;
         }
 
-        $maxOrder = Music::where('playlist_id', $playlistId)->max('order');
+        $maxOrder = \DB::table('music_playlist')
+            ->where('playlist_id', $playlistId)
+            ->max('order');
+
         return ($maxOrder ?? -1) + 1;
     }
 
@@ -188,11 +232,9 @@ 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|integer|min:1',
-                'duration' => 'nullable|string|regex:/^(?:\d+:)?[0-5]?\d:[0-5]\d$/',
-                'order' => 'nullable|integer',
                 'is_active' => 'nullable|boolean',
             ]);
 
@@ -209,7 +251,7 @@ public function update(Request $request, $id)
 
             return response()->json([
                 'message' => 'Music updated successfully',
-                'music' => $music->load(['image', 'playlist', 'tags']),
+                'music' => $music->load(['image', 'playlists', 'tags']),
                 'url' => asset('storage/' . $music->file_path),
             ]);
             
@@ -229,7 +271,7 @@ public function show($id)
 
     $music = Music::with([
             'image',
-            'playlist', 
+            'playlists',
             'tags',
             'comments' => function($query) {
                 $query->with('user')->latest()->limit(10);

app/Http/Controllers/MusicPlaylistController.php

@@ -8,61 +8,114 @@
 
 class MusicPlaylistController extends Controller
 {
-    public function index(Request $request)
+   public function index(Request $request, $categoryId = null)
-    {
+        {
-        $query = MusicPlaylist::with(['category', 'image']);
+            $query = MusicPlaylist::with(['categories', 'subcategories', 'image']);
 
-        if ($request->has('category_id')) {
+            $categoryId = $categoryId ?? $request->input('category_id');
-            $query->where('category_id', $request->category_id);
+
+            if ($categoryId) {
+                $query->whereHas('categories', function ($q) use ($categoryId) {
+                    $q->where('music_categories.id', $categoryId);
+                });
+            }
+
+            if ($request->filled('subcategory_id')) {
+                $subcategoryId = $request->input('subcategory_id');
+                $query->whereHas('subcategories', function ($q) use ($subcategoryId) {
+                    $q->where('music_subcategories.id', $subcategoryId);
+                });
+            }
+
+            $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([
+    $data = $request->validate([
-            'category_id' => 'required|exists:music_categories,id',
+        'category_ids' => 'nullable|array',
-            'name' => 'required|string|max:255',
+        'category_ids.*' => 'integer|exists:music_categories,id',
-            'description' => 'nullable|string',
+        'subcategory_ids' => 'nullable|array',
-            'image_id' => 'nullable|exists:images,id',
+        'subcategory_ids.*' => 'integer|exists:music_subcategories,id',
-            'order' => 'nullable|integer',
+        'name' => 'required|string|max:255',
-            'is_active' => 'nullable|boolean',
+        'description' => 'nullable|string',
-        ]);
+        'image_id' => 'nullable|exists:images,id',
-        
+        'order' => 'nullable|integer',
-        $data['slug'] = Str::slug($data['name']);
+        'is_active' => 'nullable|boolean',
-        
+    ]);
-        $playlist = MusicPlaylist::create($data);
 
+    // Ensure at least one category or subcategory is provided
+    if (empty($data['category_ids']) && empty($data['subcategory_ids'])) {
         return response()->json([
-            'message' => 'Playlist created successfully',
+            'message' => 'At least one category or subcategory is required'
-            'playlist' => $playlist->load(['category', 'image'])
+        ], 422);
-        ], 201);
     }
 
+    $data['slug'] = Str::slug($data['name']);
+
+    $playlist = MusicPlaylist::create($data);
+
+    $playlist->categories()->sync($data['category_ids'] ?? []);
+    $playlist->subcategories()->sync($data['subcategory_ids'] ?? []);
+
+    return response()->json([
+        'message' => 'Playlist created successfully',
+        'playlist' => $playlist->load(['categories', 'subcategories', 'image'])
+    ], 201);
+}
+    
     public function show($id)
-    {
+        {
-        $playlist = MusicPlaylist::with([
+            $playlist = MusicPlaylist::with([
-            'category', 
+                'categories',
-            'image', 
+                'subcategories',
-            'musics' => function($q) {
+                'image',
-                $q->where('is_active', true)
+                'musics' => function($q) {
-                  ->with(['image', 'tags'])
+                    $q->where('music.is_active', true)
-                  ->orderBy('order');
+                    ->with(['image', 'tags'])
-            }
+                    ->orderBy('music_playlist.order');
-        ])->findOrFail($id);
+                },
+                'comments' => function($q) { // Add comments relationship
+                    $q->with('user')->latest()->limit(10);
+                }
+            ])->findOrFail($id);
+            $userComment = $playlist->userComment();
+            $comments = $playlist->comments()
+                ->with('user')
+                ->latest()
+                ->paginate(15);
             
-        return response()->json($playlist);
+            return response()->json([
-    }
+                'playlist' => $playlist,
+                'statistics' => [
+                    'total_musics' => $playlist->musics->count(),
+                    'total_duration' => $playlist->total_duration,
+                    'total_comments' => $playlist->comments_count,
+                    'total_likes' => $playlist->likes_count,
+                    'total_saves' => $playlist->saved_count,
+                ],
+                'user_interaction' => [
+                    'has_commented' => $playlist->has_user_commented,
+                    'user_comment' => $playlist->user_comment,
+                    'user_comment_id' => $playlist->user_comment_id,
+                    'has_liked' => $playlist->is_liked,
+                    'has_saved' => $playlist->is_saved,
+                ],
+                'comments' => $comments,
+            ]);
+        }
     
     public function update(Request $request, $id)
     {
         $playlist = MusicPlaylist::findOrFail($id);
         
         $data = $request->validate([
-            'category_id' => 'sometimes|exists:music_categories,id',
+            'category_ids' => 'sometimes|array',
+            'category_ids.*' => 'integer|exists:music_categories,id',
+            'subcategory_ids' => 'sometimes|array',
+            'subcategory_ids.*' => 'integer|exists:music_subcategories,id',
             'name' => 'sometimes|string|max:255',
             'description' => 'nullable|string',
             'image_id' => 'nullable|exists:images,id',
@@ -76,9 +129,17 @@ public function update(Request $request, $id)
 
         $playlist->update($data);
 
+        if (array_key_exists('category_ids', $data)) {
+            $playlist->categories()->sync($data['category_ids'] ?? []);
+        }
+
+        if (array_key_exists('subcategory_ids', $data)) {
+            $playlist->subcategories()->sync($data['subcategory_ids'] ?? []);
+        }
+
         return response()->json([
             'message' => 'Playlist updated successfully',
-            'playlist' => $playlist->load(['category', 'image'])
+            'playlist' => $playlist->load(['categories', 'subcategories', 'image'])
         ]);
     }
     

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('music.is_active', true)->with('image')->orderBy('music_playlist.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/SaveController.php

@@ -0,0 +1,227 @@
+<?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,playlist',
+            '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,playlist',
+            '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,playlist',
+            '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',
+                'playlist' => 'App\\Models\\MusicPlaylist',
+            ]
+        ]);
+    }
+    /**
+     * Check if specific item is saved by user
+     */
+    public function checkSaved(Request $request)
+    {
+        $request->validate([
+            'type' => 'required|string|in:music,media,breathing-template,playlist',
+            '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,
+            'playlist' => \App\Models\MusicPlaylist::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/Http/Controllers/SubCategoryController.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\SubCategory;
+use Illuminate\Http\Request;
+
+class SubCategoryController extends Controller
+{
+    public function index(Request $request, $categoryId = null)
+    {
+        $query = SubCategory::with('category')->withCount('media');
+
+        $categoryId = $categoryId ?? $request->input('category_id');
+
+        if ($categoryId) {
+            $query->where('category_id', $categoryId);
+        }
+
+        return response()->json(
+            $query->orderBy('name')->get()
+        );
+    }
+
+    public function store(Request $request)
+    {
+        $data = $request->validate([
+            'category_id' => 'required|exists:categories,id',
+            'name' => 'required|string|max:255',
+        ]);
+
+        $existing = SubCategory::where('category_id', $data['category_id'])
+            ->where('name', $data['name'])
+            ->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);
+        }
+
+        $subCategory = SubCategory::create($data);
+
+        return response()->json([
+            'message' => 'Subcategory created successfully',
+            'sub_category' => $subCategory->load('category'),
+        ], 201);
+    }
+
+    public function show($id)
+    {
+        $subCategory = SubCategory::with('category')->withCount('media')->findOrFail($id);
+
+        return response()->json($subCategory);
+    }
+
+    public function update(Request $request, $id)
+    {
+        $subCategory = SubCategory::findOrFail($id);
+
+        $data = $request->validate([
+            'category_id' => 'sometimes|exists:categories,id',
+            'name' => 'sometimes|string|max:255',
+        ]);
+
+        $categoryId = $data['category_id'] ?? $subCategory->category_id;
+        $name = $data['name'] ?? $subCategory->name;
+
+        $existing = SubCategory::where('category_id', $categoryId)
+            ->where('name', $name)
+            ->where('id', '!=', $subCategory->id)
+            ->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);
+        }
+
+        $subCategory->update($data);
+
+        return response()->json([
+            'message' => 'Subcategory updated successfully',
+            'sub_category' => $subCategory->load('category'),
+        ]);
+    }
+
+    public function destroy($id)
+    {
+        $subCategory = SubCategory::findOrFail($id);
+        $subCategory->delete();
+
+        return response()->json(['message' => 'Subcategory deleted successfully']);
+    }
+}

app/Http/Controllers/SurveyQuestionController.php

@@ -0,0 +1,305 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Media;
+use App\Models\SurveyAnswer;
+use App\Models\SurveyQuestion;
+use App\Models\Tag;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Validation\ValidationException;
+
+class SurveyQuestionController extends Controller
+{
+    // USER: list active questions with their options and the current user's own answers.
+    public function index(Request $request)
+    {
+        $questions = SurveyQuestion::with(['options.tags', 'userAnswers'])
+            ->where('is_active', true)
+            ->orderBy('order')
+            ->get();
+
+        return response()->json($questions);
+    }
+
+    // USER: a single question with its options and the current user's own answers.
+    public function show($id)
+    {
+        $question = SurveyQuestion::with(['options.tags', 'userAnswers'])->findOrFail($id);
+
+        return response()->json($question);
+    }
+
+    // ADMIN: list every question (incl. inactive) with options (+ vote tallies) and all answers.
+    public function adminIndex(Request $request)
+    {
+        $questions = SurveyQuestion::with([
+                'options' => fn ($q) => $q->withCount('answers')->with('tags'),
+                'answers' => fn ($q) => $q->with(['user', 'option']),
+            ])
+            ->orderBy('order')
+            ->get();
+
+        return response()->json($questions);
+    }
+
+    // ADMIN: a single question with options (+ vote tallies) and all users' answers.
+    public function adminShow($id)
+    {
+        $question = SurveyQuestion::with([
+                'options' => fn ($q) => $q->withCount('answers')->with('tags'),
+                'answers' => fn ($q) => $q->with(['user', 'option']),
+            ])
+            ->findOrFail($id);
+
+        return response()->json($question);
+    }
+
+    // ADMIN: clean aggregated results — per option vote counts & percentages, no raw rows.
+    // Pass an $id for one question, omit it for all questions.
+    public function adminAnalytics($id = null)
+    {
+        $query = SurveyQuestion::with(['options' => fn ($q) => $q->withCount('answers')]);
+
+        if (!is_null($id)) {
+            $query->where('id', $id);
+        }
+
+        $questions = $query->orderBy('order')->get();
+
+        if (!is_null($id) && $questions->isEmpty()) {
+            abort(404);
+        }
+
+        $analytics = $questions->map(function (SurveyQuestion $question) {
+            // Respondents = distinct users who answered (not number of selections).
+            $respondents = $question->answers()->distinct('user_id')->count('user_id');
+            $totalSelections = (int) $question->options->sum('answers_count');
+
+            return [
+                'id' => $question->id,
+                'question' => $question->question,
+                'description' => $question->description,
+                'type' => $question->type,
+                'is_active' => $question->is_active,
+                'total_respondents' => $respondents,
+                'total_selections' => $totalSelections,
+                'options' => $question->options->map(function ($option) use ($respondents) {
+                    $votes = (int) $option->answers_count;
+
+                    return [
+                        'id' => $option->id,
+                        'label' => $option->label,
+                        'value' => $option->value,
+                        'votes' => $votes,
+                        // % of respondents who picked this option (can exceed 100% summed for multi-select).
+                        'percentage' => $respondents > 0 ? round($votes / $respondents * 100, 1) : 0,
+                    ];
+                })->values(),
+            ];
+        });
+
+        return response()->json(is_null($id) ? $analytics->values() : $analytics->first());
+    }
+
+    // CREATE a question together with its options.
+    public function store(Request $request)
+    {
+        $data = $request->validate([
+            'question' => 'required|string|max:255',
+            'description' => 'nullable|string',
+            'type' => 'required|in:single,multiple',
+            'order' => 'nullable|integer',
+            'is_active' => 'nullable|boolean',
+            'options' => 'required|array|min:1',
+            'options.*.label' => 'required|string|max:255',
+            'options.*.value' => 'nullable|string|max:255',
+            'options.*.order' => 'nullable|integer',
+            'options.*.tags' => 'nullable|array',
+            'options.*.tags.*' => 'string',
+        ]);
+
+        $question = DB::transaction(function () use ($data) {
+            $question = SurveyQuestion::create([
+                'question' => $data['question'],
+                'description' => $data['description'] ?? null,
+                'type' => $data['type'],
+                'order' => $data['order'] ?? 0,
+                'is_active' => $data['is_active'] ?? true,
+            ]);
+
+            $this->syncOptions($question, $data['options']);
+
+            return $question;
+        });
+
+        return response()->json([
+            'message' => 'Question created successfully',
+            'question' => $question->load('options.tags'),
+        ], 201);
+    }
+
+    // UPDATE a question; if options are provided they replace the existing set.
+    public function update(Request $request, $id)
+    {
+        $question = SurveyQuestion::findOrFail($id);
+
+        $data = $request->validate([
+            'question' => 'sometimes|string|max:255',
+            'description' => 'nullable|string',
+            'type' => 'sometimes|in:single,multiple',
+            'order' => 'nullable|integer',
+            'is_active' => 'nullable|boolean',
+            'options' => 'sometimes|array|min:1',
+            'options.*.label' => 'required_with:options|string|max:255',
+            'options.*.value' => 'nullable|string|max:255',
+            'options.*.order' => 'nullable|integer',
+            'options.*.tags' => 'nullable|array',
+            'options.*.tags.*' => 'string',
+        ]);
+
+        DB::transaction(function () use ($question, $data) {
+            $question->update(array_filter(
+                [
+                    'question' => $data['question'] ?? null,
+                    'description' => array_key_exists('description', $data) ? $data['description'] : null,
+                    'type' => $data['type'] ?? null,
+                    'order' => $data['order'] ?? null,
+                    'is_active' => $data['is_active'] ?? null,
+                ],
+                fn ($value) => !is_null($value)
+            ));
+
+            if (array_key_exists('options', $data)) {
+                // Replacing options invalidates existing answers for this question.
+                $question->answers()->delete();
+                $question->options()->delete();
+                $this->syncOptions($question, $data['options']);
+            }
+        });
+
+        return response()->json([
+            'message' => 'Question updated successfully',
+            'question' => $question->load('options.tags'),
+        ]);
+    }
+
+    public function destroy($id)
+    {
+        $question = SurveyQuestion::findOrFail($id);
+        $question->delete(); // options + answers cascade
+
+        return response()->json(['message' => 'Question deleted successfully']);
+    }
+
+    // USER submits their answer(s) for a question.
+    public function answer(Request $request, $id)
+    {
+        $question = SurveyQuestion::findOrFail($id);
+
+        $data = $request->validate([
+            'option_ids' => 'required|array|min:1',
+            'option_ids.*' => 'integer',
+        ]);
+
+        $optionIds = array_values(array_unique($data['option_ids']));
+
+        // Every selected option must belong to this question.
+        $validOptionIds = $question->options()->pluck('id')->all();
+        if (array_diff($optionIds, $validOptionIds)) {
+            throw ValidationException::withMessages([
+                'option_ids' => ['One or more options do not belong to this question.'],
+            ]);
+        }
+
+        // Enforce single vs multiple selection.
+        if ($question->type === 'single' && count($optionIds) > 1) {
+            throw ValidationException::withMessages([
+                'option_ids' => ['This question allows only a single option.'],
+            ]);
+        }
+
+        $userId = auth()->id();
+
+        DB::transaction(function () use ($question, $optionIds, $userId) {
+            // Replace any previous answer for this user + question.
+            $question->answers()->where('user_id', $userId)->delete();
+
+            $rows = array_map(fn ($optionId) => [
+                'user_id' => $userId,
+                'survey_question_id' => $question->id,
+                'survey_option_id' => $optionId,
+                'created_at' => now(),
+                'updated_at' => now(),
+            ], $optionIds);
+
+            $question->answers()->getRelated()->insert($rows);
+        });
+
+        return response()->json([
+            'message' => 'Answer submitted successfully',
+            'question' => $question->load(['options', 'userAnswers']),
+        ]);
+    }
+
+    // USER: suggest media based on the tags attached to the options this user has chosen.
+    public function suggestedMedia(Request $request)
+    {
+        $userId = auth()->id();
+
+        $answersQuery = SurveyAnswer::where('user_id', $userId);
+        if ($request->filled('question_id')) {
+            $answersQuery->where('survey_question_id', $request->question_id);
+        }
+        $optionIds = $answersQuery->pluck('survey_option_id');
+
+        if ($optionIds->isEmpty()) {
+            return response()->json([]);
+        }
+
+        // Collect the tags behind the chosen options.
+        $tagIds = DB::table('survey_option_tag')
+            ->whereIn('survey_option_id', $optionIds)
+            ->pluck('tag_id')
+            ->unique()
+            ->values();
+
+        if ($tagIds->isEmpty()) {
+            return response()->json([]);
+        }
+
+        // Media sharing those tags, ranked by how many of them match.
+        $media = Media::query()
+            ->whereHas('tags', fn ($q) => $q->whereIn('tags.id', $tagIds))
+            ->withCount(['tags as match_count' => fn ($q) => $q->whereIn('tags.id', $tagIds)])
+            ->where(function ($q) use ($userId) {
+                $q->where('visibility', 'public')->orWhere('user_id', $userId);
+            })
+            ->with(['image', 'categories', 'subCategories', 'tags'])
+            ->orderByDesc('match_count')
+            ->orderByDesc('created_at')
+            ->get();
+
+        return response()->json($media);
+    }
+
+    private function syncOptions(SurveyQuestion $question, array $options): void
+    {
+        foreach (array_values($options) as $i => $option) {
+            $created = $question->options()->create([
+                'label' => $option['label'],
+                'value' => $option['value'] ?? null,
+                'order' => $option['order'] ?? $i,
+            ]);
+
+            if (!empty($option['tags'])) {
+                $tagIds = collect($option['tags'])
+                    ->map(fn ($name) => Tag::firstOrCreate(['name' => $name])->id)
+                    ->all();
+
+                $created->tags()->sync($tagIds);
+            }
+        }
+    }
+}

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/Category.php

@@ -12,5 +12,15 @@ public function questions()
     {
         return $this->hasMany(Question::class);
     }
+
+    public function subcategories()
+    {
+        return $this->hasMany(SubCategory::class);
+    }
+
+    public function media()
+    {
+        return $this->belongsToMany(Media::class, 'category_media');
+    }
 }
 

app/Models/Like.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+class Like extends Model
+{
+    protected $table = 'likes';
+    
+    protected $fillable = [
+        'user_id',
+        'likeable_id',
+        'likeable_type',
+    ];
+    
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+    
+    public function likeable(): MorphTo
+    {
+        return $this->morphTo();
+    }
+    
+    // Helper methods
+    public static function getLikedItemsForUser($userId, $type = null)
+    {
+        $query = self::with('likeable')->where('user_id', $userId);
+        
+        if ($type) {
+            $query->where('likeable_type', $type);
+        }
+        
+        return $query->latest()->get();
+    }
+    
+    public static function isLikedByUser($userId, $likeableId, $likeableType)
+    {
+        return self::where([
+            'user_id' => $userId,
+            'likeable_id' => $likeableId,
+            'likeable_type' => $likeableType,
+        ])->exists();
+    }
+    
+    public static function getLikeCount($likeableId, $likeableType)
+    {
+        return self::where([
+            'likeable_id' => $likeableId,
+            'likeable_type' => $likeableType,
+        ])->count();
+    }
+}

app/Models/Media.php

@@ -5,13 +5,14 @@
 use Illuminate\Database\Eloquent\Model;
 use App\Traits\HasRatings;
 use App\Traits\HasComments;
+use App\Traits\HasSaves;
+use App\Traits\HasLikes;
 class Media extends Model
 {
-     use HasRatings, HasComments;
+     use HasRatings, HasComments,HasSaves,HasLikes;
   protected $fillable = [
         'user_id',
         'image_id',
-        'category_id',
         'title',
         'caption',
         'type',
@@ -21,29 +22,45 @@ class Media extends Model
         'visibility',
         'is_premium'
     ];
-protected $appends = [
+    protected $appends = [
-    'average_rating',
+        'average_rating',
         'user_rating',
         'ratings_count',
         'comments_count',
-         'has_user_commented',      // Add this
+        'has_user_commented',    
-        'user_comment',            // Add this
+        'user_comment',         
-        'user_comment_id',         // Add this
+        'user_comment_id',      
-        'has_user_rated'           // Add this
+        'has_user_rated',   
-];
+        'is_saved', 
+        'saved_count',
+        'is_liked',   
+        'likes_count',
+'is_liked',
+        'likes_count', 
+    ];
     public function image()
     {
         return $this->belongsTo(Image::class);
     }
 
-    public function category()
+    public function categories()
     {
-        return $this->belongsTo(Category::class);
+        return $this->belongsToMany(Category::class, 'category_media');
+    }
+
+    public function subCategories()
+    {
+        return $this->belongsToMany(SubCategory::class, 'media_sub_category');
     }
     public function tags()
     {
         return $this->belongsToMany(Tag::class, 'media_tag');
     }
+
+    public function plays()
+    {
+        return $this->hasMany(MediaPlay::class);
+    }
     public function notes()
     {
         return $this->morphMany(Note::class, 'noteable');

app/Models/MediaPlay.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class MediaPlay extends Model
+{
+    protected $fillable = ['user_id', 'media_id', 'play_count', 'last_played_at'];
+
+    protected $casts = [
+        'play_count' => 'integer',
+        'last_played_at' => 'datetime',
+    ];
+
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+
+    public function media(): BelongsTo
+    {
+        return $this->belongsTo(Media::class);
+    }
+}

app/Models/Music.php

@@ -10,20 +10,21 @@
 use Illuminate\Database\Eloquent\Relations\MorphMany;    // ← Add this
 use App\Traits\HasRatings;
 use App\Traits\HasComments;
+use App\Traits\HasSaves;
+use App\Traits\HasLikes;
 
 class Music extends Model
 {   
-     use HasFactory, HasRatings, HasComments;
+     use HasFactory, HasRatings, HasComments , HasSaves,HasLikes;
      protected $table = 'music';
     
 
     protected $fillable = [
     'user_id', 'title', 'artist', 'file_path', 'type',
-        'playlist_id', 'image_id', 'duration', 'order', 'is_active'
+        'image_id', 'duration', 'is_active'
     ];
  protected $casts = [
-        'duration' => 'string',
+        'duration' => 'integer',
-        'order' => 'integer',
         'is_active' => 'boolean',
     ];
     protected $attributes = [
@@ -34,19 +35,30 @@ public function user()
     {
         return $this->belongsTo(User::class);
     }
-     public function playlist(): BelongsTo
+     public function playlists(): BelongsToMany
     {
-        return $this->belongsTo(MusicPlaylist::class, 'playlist_id');
+        return $this->belongsToMany(MusicPlaylist::class, 'music_playlist', 'music_id', 'playlist_id')
+            ->withPivot('order')
+            ->withTimestamps();
     }
      public function tags(): BelongsToMany
     {
         return $this->belongsToMany(Tag::class, 'music_tags');
     }
     
-    protected $appends = ['url', 'image_url' , 'average_rating', 'user_rating', 'comments_count' ,     'has_user_commented',      // Add this
+    protected $appends = ['url',
-    'user_comment',            // Add this
+    'image_url' , 
-    'user_comment_id',         // Add this
+    'average_rating',
-    'has_user_rated'           // Add this];
+    'user_rating', 
+    'comments_count' , 
+    'has_user_commented',  
+    'user_comment',         
+    'user_comment_id',         
+    'has_user_rated' ,
+    'is_saved', 
+    'saved_count',
+    'is_liked',
+    'likes_count'      
     ];
 
     public function getUrlAttribute()

app/Models/MusicCategory.php

@@ -4,6 +4,7 @@
 
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;  // ← Add this
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
 use Illuminate\Database\Eloquent\Relations\HasMany;    // ← Add this
 class MusicCategory extends Model
 {
@@ -18,11 +19,26 @@ class MusicCategory extends Model
         'order' => 'integer',
     ];
 
-    public function playlists(): HasMany
+    public function playlists(): BelongsToMany
     {
-        return $this->hasMany(MusicPlaylist::class, 'category_id');
+        return $this->belongsToMany(MusicPlaylist::class, 'music_category_playlist', 'category_id', 'playlist_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);
@@ -30,6 +46,20 @@ public function image(): BelongsTo
     
     public function getActivePlaylistsAttribute()
     {
-        return $this->playlists()->where('is_active', true)->get();
+        return $this->playlists()->where('music_playlists.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

@@ -4,28 +4,50 @@
 
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;  // ← Add this
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
 use Illuminate\Database\Eloquent\Relations\HasMany;    // ← Add this
+use App\Traits\HasComments; // Add this
+use App\Traits\HasLikes;
+use App\Traits\HasSaves;
 class MusicPlaylist extends Model
 {
+    use HasComments, HasLikes, HasSaves;
     protected $table = 'music_playlists';
     
     protected $fillable = [
-        'category_id', 'name', 'slug', 'description', 'image_id', 'order', 'is_active'
+        'name', 'slug', 'description', 'image_id', 'order', 'is_active'
     ];
     
     protected $casts = [
         'is_active' => 'boolean',
         'order' => 'integer',
     ];
-    
+    protected $appends = [
-    public function category(): BelongsTo
+        'comments_count',
+        'has_user_commented',
+        'user_comment',
+        'user_comment_id',
+        'is_liked',
+        'likes_count',
+        'is_saved',
+        'saved_count'
+    ];
+    public function categories(): BelongsToMany
     {
-        return $this->belongsTo(MusicCategory::class, 'category_id');
+        return $this->belongsToMany(MusicCategory::class, 'music_category_playlist', 'playlist_id', 'category_id');
     }
 
-    public function musics(): HasMany
+    public function subcategories(): BelongsToMany
     {
-        return $this->hasMany(Music::class, 'playlist_id');
+        return $this->belongsToMany(MusicSubcategory::class, 'music_subcategory_playlist', 'playlist_id', 'subcategory_id');
+    }
+    
+    
+    public function musics(): BelongsToMany
+    {
+        return $this->belongsToMany(Music::class, 'music_playlist', 'playlist_id', 'music_id')
+            ->withPivot('order')
+            ->withTimestamps();
     }
     
     public function image(): BelongsTo
@@ -35,11 +57,11 @@ public function image(): BelongsTo
     
     public function getActiveMusicsAttribute()
     {
-        return $this->musics()->where('is_active', true)->orderBy('order')->get();
+        return $this->musics()->where('music.is_active', true)->orderBy('music_playlist.order')->get();
     }
 
     public function getTotalDurationAttribute()
     {
-        return $this->musics()->where('is_active', true)->sum('duration');
+        return $this->musics()->where('music.is_active', true)->sum('music.duration');
     }
 }

app/Models/MusicSubcategory.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
+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(): BelongsToMany
+    {
+        return $this->belongsToMany(MusicPlaylist::class, 'music_subcategory_playlist', 'subcategory_id', 'playlist_id');
+    }
+    
+    public function image(): BelongsTo
+    {
+        return $this->belongsTo(Image::class);
+    }
+    
+    public function getActivePlaylistsAttribute()
+    {
+        return $this->playlists()->where('music_playlists.is_active', true)->orderBy('music_playlists.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/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/Models/SubCategory.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
+
+class SubCategory extends Model
+{
+    protected $table = 'sub_categories';
+
+    protected $fillable = ['category_id', 'name'];
+
+    public function category(): BelongsTo
+    {
+        return $this->belongsTo(Category::class);
+    }
+
+    public function media(): BelongsToMany
+    {
+        return $this->belongsToMany(Media::class, 'media_sub_category');
+    }
+}

app/Models/SurveyAnswer.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class SurveyAnswer extends Model
+{
+    protected $fillable = ['user_id', 'survey_question_id', 'survey_option_id'];
+
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+
+    public function question(): BelongsTo
+    {
+        return $this->belongsTo(SurveyQuestion::class, 'survey_question_id');
+    }
+
+    public function option(): BelongsTo
+    {
+        return $this->belongsTo(SurveyOption::class, 'survey_option_id');
+    }
+}

app/Models/SurveyOption.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+class SurveyOption extends Model
+{
+    protected $fillable = ['survey_question_id', 'label', 'value', 'order'];
+
+    protected $casts = [
+        'order' => 'integer',
+    ];
+
+    public function question(): BelongsTo
+    {
+        return $this->belongsTo(SurveyQuestion::class, 'survey_question_id');
+    }
+
+    public function answers(): HasMany
+    {
+        return $this->hasMany(SurveyAnswer::class);
+    }
+
+    // Tags used to suggest media when a user picks this option.
+    public function tags(): BelongsToMany
+    {
+        return $this->belongsToMany(Tag::class, 'survey_option_tag');
+    }
+}

app/Models/SurveyQuestion.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+class SurveyQuestion extends Model
+{
+    protected $fillable = ['question', 'description', 'type', 'order', 'is_active'];
+
+    protected $casts = [
+        'is_active' => 'boolean',
+        'order' => 'integer',
+    ];
+
+    public function options(): HasMany
+    {
+        return $this->hasMany(SurveyOption::class)->orderBy('order');
+    }
+
+    public function answers(): HasMany
+    {
+        return $this->hasMany(SurveyAnswer::class);
+    }
+
+    // The current user's selected option ids for this question.
+    public function userAnswers(): HasMany
+    {
+        return $this->hasMany(SurveyAnswer::class)->where('user_id', auth()->id());
+    }
+}

app/Traits/HasLikes.php

@@ -0,0 +1,59 @@
+<?php
+// app/Traits/HasLikes.php
+namespace App\Traits;
+
+use App\Models\Like;
+use Illuminate\Database\Eloquent\Relations\MorphMany;
+
+trait HasLikes
+{
+    public function likes(): MorphMany
+    {
+        return $this->morphMany(Like::class, 'likeable');
+    }
+    
+    public function getIsLikedAttribute()
+    {
+        if (!auth()->check()) return false;
+        
+        return $this->likes()
+            ->where('user_id', auth()->id())
+            ->exists();
+    }
+    
+    public function getLikesCountAttribute()
+    {
+        return $this->likes()->count();
+    }
+    
+    public function toggleLike()
+    {
+        if ($this->getIsLikedAttribute()) {
+            return $this->removeLike();
+        } else {
+            return $this->addLike();
+        }
+    }
+    
+    public function addLike()
+    {
+        if ($this->getIsLikedAttribute()) return false;
+        
+        return Like::create([
+            'user_id' => auth()->id(),
+            'likeable_id' => $this->id,
+            'likeable_type' => get_class($this),
+        ]);
+    }
+    
+    public function removeLike()
+    {
+        if (!$this->getIsLikedAttribute()) return false;
+        
+        return Like::where([
+            'user_id' => auth()->id(),
+            'likeable_id' => $this->id,
+            'likeable_type' => get_class($this),
+        ])->delete();
+    }
+}

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_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,55 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+use Illuminate\Support\Facades\DB;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        // Get the database driver
+        $driver = DB::connection()->getDriverName();
+        
+        if ($driver === 'pgsql') {
+            // PostgreSQL: Use raw statement with USING clause
+            DB::statement('ALTER TABLE music ALTER COLUMN duration TYPE integer USING (duration::integer)');
+            
+            Schema::table('music', function (Blueprint $table) {
+                $table->integer('duration')->nullable()->change();
+            });
+        } elseif ($driver === 'mysql') {
+            // MySQL: Can directly change column type
+            Schema::table('music', function (Blueprint $table) {
+                $table->integer('duration')->nullable()->change();
+            });
+        }
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        // Get the database driver
+        $driver = DB::connection()->getDriverName();
+        
+        if ($driver === 'pgsql') {
+            // PostgreSQL: Convert back to text
+            DB::statement('ALTER TABLE music ALTER COLUMN duration TYPE text USING (duration::text)');
+            
+            Schema::table('music', function (Blueprint $table) {
+                $table->string('duration')->nullable()->change();
+            });
+        } elseif ($driver === 'mysql') {
+            // MySQL: Change back to string
+            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');
+    }
+};

database/migrations/2026_05_24_192058_create_likes_table.php

@@ -0,0 +1,30 @@
+<?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('likes', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('user_id')->constrained()->onDelete('cascade');
+            $table->morphs('likeable'); 
+            $table->timestamps();
+            $table->unique(['user_id', 'likeable_id', 'likeable_type']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('likes');
+    }
+};

database/migrations/2026_05_30_100000_create_sub_categories_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('sub_categories', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('category_id')->constrained('categories')->cascadeOnDelete();
+            $table->string('name');
+            $table->timestamps();
+
+            $table->unique(['category_id', 'name']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('sub_categories');
+    }
+};

database/migrations/2026_05_30_100100_add_subcategory_id_to_media_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::table('media', function (Blueprint $table) {
+            $table->unsignedBigInteger('subcategory_id')->nullable()->after('category_id');
+
+            $table->foreign('subcategory_id')->references('id')->on('sub_categories')->nullOnDelete();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('media', function (Blueprint $table) {
+            $table->dropForeign(['subcategory_id']);
+            $table->dropColumn('subcategory_id');
+        });
+    }
+};

database/migrations/2026_05_31_100000_create_media_category_pivot_tables.php

@@ -0,0 +1,79 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('category_media', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('media_id')->constrained('media')->cascadeOnDelete();
+            $table->foreignId('category_id')->constrained('categories')->cascadeOnDelete();
+            $table->timestamps();
+
+            $table->unique(['media_id', 'category_id']);
+        });
+
+        Schema::create('media_sub_category', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('media_id')->constrained('media')->cascadeOnDelete();
+            $table->foreignId('sub_category_id')->constrained('sub_categories')->cascadeOnDelete();
+            $table->timestamps();
+
+            $table->unique(['media_id', 'sub_category_id']);
+        });
+
+        // Backfill the new pivots from the existing single columns.
+        if (Schema::hasColumn('media', 'category_id')) {
+            DB::table('media')
+                ->whereNotNull('category_id')
+                ->orderBy('id')
+                ->select('id', 'category_id')
+                ->chunk(200, function ($rows) {
+                    $now = now();
+                    $insert = $rows->map(fn ($row) => [
+                        'media_id' => $row->id,
+                        'category_id' => $row->category_id,
+                        'created_at' => $now,
+                        'updated_at' => $now,
+                    ])->all();
+
+                    DB::table('category_media')->insertOrIgnore($insert);
+                });
+        }
+
+        if (Schema::hasColumn('media', 'subcategory_id')) {
+            DB::table('media')
+                ->whereNotNull('subcategory_id')
+                ->orderBy('id')
+                ->select('id', 'subcategory_id')
+                ->chunk(200, function ($rows) {
+                    $now = now();
+                    $insert = $rows->map(fn ($row) => [
+                        'media_id' => $row->id,
+                        'sub_category_id' => $row->subcategory_id,
+                        'created_at' => $now,
+                        'updated_at' => $now,
+                    ])->all();
+
+                    DB::table('media_sub_category')->insertOrIgnore($insert);
+                });
+        }
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('media_sub_category');
+        Schema::dropIfExists('category_media');
+    }
+};

database/migrations/2026_05_31_100100_drop_category_columns_from_media_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::table('media', function (Blueprint $table) {
+            $table->dropForeign(['category_id']);
+            $table->dropColumn('category_id');
+
+            $table->dropForeign(['subcategory_id']);
+            $table->dropColumn('subcategory_id');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('media', function (Blueprint $table) {
+            $table->unsignedBigInteger('category_id')->nullable()->after('image_id');
+            $table->foreign('category_id')->references('id')->on('categories')->nullOnDelete();
+
+            $table->unsignedBigInteger('subcategory_id')->nullable()->after('category_id');
+            $table->foreign('subcategory_id')->references('id')->on('sub_categories')->nullOnDelete();
+        });
+    }
+};

database/migrations/2026_05_31_110000_create_music_playlist_category_pivot_tables.php

@@ -0,0 +1,79 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('music_category_playlist', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('playlist_id')->constrained('music_playlists')->cascadeOnDelete();
+            $table->foreignId('category_id')->constrained('music_categories')->cascadeOnDelete();
+            $table->timestamps();
+
+            $table->unique(['playlist_id', 'category_id']);
+        });
+
+        Schema::create('music_subcategory_playlist', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('playlist_id')->constrained('music_playlists')->cascadeOnDelete();
+            $table->foreignId('subcategory_id')->constrained('music_subcategories')->cascadeOnDelete();
+            $table->timestamps();
+
+            $table->unique(['playlist_id', 'subcategory_id']);
+        });
+
+        // Backfill the new pivots from the existing single columns.
+        if (Schema::hasColumn('music_playlists', 'category_id')) {
+            DB::table('music_playlists')
+                ->whereNotNull('category_id')
+                ->orderBy('id')
+                ->select('id', 'category_id')
+                ->chunk(200, function ($rows) {
+                    $now = now();
+                    $insert = $rows->map(fn ($row) => [
+                        'playlist_id' => $row->id,
+                        'category_id' => $row->category_id,
+                        'created_at' => $now,
+                        'updated_at' => $now,
+                    ])->all();
+
+                    DB::table('music_category_playlist')->insertOrIgnore($insert);
+                });
+        }
+
+        if (Schema::hasColumn('music_playlists', 'subcategory_id')) {
+            DB::table('music_playlists')
+                ->whereNotNull('subcategory_id')
+                ->orderBy('id')
+                ->select('id', 'subcategory_id')
+                ->chunk(200, function ($rows) {
+                    $now = now();
+                    $insert = $rows->map(fn ($row) => [
+                        'playlist_id' => $row->id,
+                        'subcategory_id' => $row->subcategory_id,
+                        'created_at' => $now,
+                        'updated_at' => $now,
+                    ])->all();
+
+                    DB::table('music_subcategory_playlist')->insertOrIgnore($insert);
+                });
+        }
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('music_subcategory_playlist');
+        Schema::dropIfExists('music_category_playlist');
+    }
+};

database/migrations/2026_05_31_110100_drop_category_columns_from_music_playlists_table.php

@@ -0,0 +1,35 @@
+<?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->dropForeign(['subcategory_id']);
+            $table->dropColumn('subcategory_id');
+
+            $table->dropForeign(['category_id']);
+            $table->dropColumn('category_id');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('music_playlists', function (Blueprint $table) {
+            $table->foreignId('category_id')->nullable()->after('id')
+                ->constrained('music_categories')->nullOnDelete();
+            $table->foreignId('subcategory_id')->nullable()->after('category_id')
+                ->constrained('music_subcategories')->nullOnDelete();
+        });
+    }
+};

database/migrations/2026_05_31_120000_create_music_playlist_pivot_table.php

@@ -0,0 +1,53 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('music_playlist', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('music_id')->constrained('music')->cascadeOnDelete();
+            $table->foreignId('playlist_id')->constrained('music_playlists')->cascadeOnDelete();
+            $table->integer('order')->default(0);
+            $table->timestamps();
+
+            $table->unique(['music_id', 'playlist_id']);
+        });
+
+        // Backfill the pivot from the existing single playlist_id column.
+        if (Schema::hasColumn('music', 'playlist_id')) {
+            DB::table('music')
+                ->whereNotNull('playlist_id')
+                ->orderBy('id')
+                ->select('id', 'playlist_id', 'order')
+                ->chunk(200, function ($rows) {
+                    $now = now();
+                    $insert = $rows->map(fn ($row) => [
+                        'music_id' => $row->id,
+                        'playlist_id' => $row->playlist_id,
+                        'order' => $row->order ?? 0,
+                        'created_at' => $now,
+                        'updated_at' => $now,
+                    ])->all();
+
+                    DB::table('music_playlist')->insertOrIgnore($insert);
+                });
+        }
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('music_playlist');
+    }
+};

database/migrations/2026_05_31_120100_drop_playlist_columns_from_music_table.php

@@ -0,0 +1,32 @@
+<?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->dropForeign(['playlist_id']);
+            $table->dropColumn('playlist_id');
+            $table->dropColumn('order');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::table('music', function (Blueprint $table) {
+            $table->foreignId('playlist_id')->nullable()->after('type')
+                ->constrained('music_playlists')->nullOnDelete();
+            $table->integer('order')->default(0)->after('duration');
+        });
+    }
+};

database/migrations/2026_06_01_100000_create_survey_questions_table.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::create('survey_questions', function (Blueprint $table) {
+            $table->id();
+            $table->string('question');
+            $table->text('description')->nullable();
+            // single = user picks exactly one option, multiple = user can pick many
+            $table->enum('type', ['single', 'multiple'])->default('single');
+            $table->integer('order')->default(0);
+            $table->boolean('is_active')->default(true);
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('survey_questions');
+    }
+};

database/migrations/2026_06_01_100100_create_survey_options_table.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::create('survey_options', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('survey_question_id')->constrained('survey_questions')->cascadeOnDelete();
+            $table->string('label');
+            $table->string('value')->nullable(); // optional machine value
+            $table->integer('order')->default(0);
+            $table->timestamps();
+
+            $table->index(['survey_question_id', 'order']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('survey_options');
+    }
+};

database/migrations/2026_06_01_100200_create_survey_answers_table.php

@@ -0,0 +1,34 @@
+<?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('survey_answers', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('user_id')->constrained('users')->cascadeOnDelete();
+            $table->foreignId('survey_question_id')->constrained('survey_questions')->cascadeOnDelete();
+            $table->foreignId('survey_option_id')->constrained('survey_options')->cascadeOnDelete();
+            $table->timestamps();
+
+            // A user can select a given option only once.
+            $table->unique(['user_id', 'survey_option_id']);
+            $table->index(['user_id', 'survey_question_id']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('survey_answers');
+    }
+};

database/migrations/2026_06_01_110000_create_survey_option_tag_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('survey_option_tag', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('survey_option_id')->constrained('survey_options')->cascadeOnDelete();
+            $table->foreignId('tag_id')->constrained('tags')->cascadeOnDelete();
+            $table->timestamps();
+
+            $table->unique(['survey_option_id', 'tag_id']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('survey_option_tag');
+    }
+};

database/migrations/2026_06_01_120000_create_media_plays_table.php

@@ -0,0 +1,35 @@
+<?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('media_plays', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('user_id')->constrained('users')->cascadeOnDelete();
+            $table->foreignId('media_id')->constrained('media')->cascadeOnDelete();
+            $table->unsignedInteger('play_count')->default(0);
+            $table->timestamp('last_played_at')->nullable();
+            $table->timestamps();
+
+            // One row per user + media; updated on each play.
+            $table->unique(['user_id', 'media_id']);
+            $table->index('last_played_at');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('media_plays');
+    }
+};

routes/api.php

@@ -11,15 +11,20 @@
 use App\Http\Controllers\WorryController;
 use Illuminate\Support\Facades\Hash;
 use App\Http\Controllers\QuestionController;
+use App\Http\Controllers\SurveyQuestionController;
 use App\Http\Controllers\SliderController;
 use App\Http\Controllers\ImageController;
 use App\Http\Controllers\MusicController;
 use App\Http\Controllers\MediaController;
+use App\Http\Controllers\CategoryController;
+use App\Http\Controllers\SubCategoryController;
 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;
+use App\Http\Controllers\LikeController;
 
 Route::get('/test-hash', function() {
     $plain = 'amnk1380';
@@ -112,6 +117,21 @@
     Route::delete('/questions/{question}', [QuestionController::class, 'destroy']);
 
 
+    /// survey questions feature (question + description + single/multi options, answered by users)
+    // Admin: see all users' answers (must be registered before the resource so it isn't caught by {survey_question}).
+    Route::middleware('abilities:admin')->group(function () {
+        // Aggregated analytics — register before the {id} routes so "analytics" isn't read as an id.
+        Route::get('/admin/survey-questions/analytics', [SurveyQuestionController::class, 'adminAnalytics']);
+        Route::get('/admin/survey-questions/{id}/analytics', [SurveyQuestionController::class, 'adminAnalytics']);
+        Route::get('/admin/survey-questions', [SurveyQuestionController::class, 'adminIndex']);
+        Route::get('/admin/survey-questions/{id}', [SurveyQuestionController::class, 'adminShow']);
+    });
+    // User: answer + read questions with their own answers only.
+    Route::get('/survey-questions/suggested-media', [SurveyQuestionController::class, 'suggestedMedia']);
+    Route::post('/survey-questions/{id}/answer', [SurveyQuestionController::class, 'answer']);
+    Route::apiResource('survey-questions', SurveyQuestionController::class);
+
+
     /// slider feature
     // Route::get('/slider', [SliderController::class, 'index']);
 
@@ -141,12 +161,15 @@
 
     ///media
     Route::get('/media/filters', [MediaController::class, 'filters']);
+    Route::get('/media/popular', [MediaController::class, 'popular']);
+    Route::get('/media/recently-played', [MediaController::class, 'recentlyPlayed']);
     Route::post('/media', [MediaController::class, 'store']);
     Route::get('/media', [MediaController::class, 'index']);
     Route::post('/media/{id}', [MediaController::class, 'update']);
     Route::get('/media/saved', [MediaController::class, 'saved']);
     Route::delete('/media/{id}', [MediaController::class, 'destroy']);
     Route::get('/media/{id}', [MediaController::class, 'show']);
+    Route::post('/media/{id}/play', [MediaController::class, 'recordPlay']);
     Route::post('/media/{id}/save', [MediaController::class, 'toggleSaveMedia']);
     Route::post('/media/{id}/rate', [MediaController::class, 'rate']);
     Route::post('/media/{id}/comment', [MediaController::class, 'storeComment']);
@@ -156,6 +179,13 @@
     //add note to media
     Route::post('/media/{id}/note', [MediaController::class, 'storeNote']);
 
+    // Media categories
+    Route::apiResource('categories', CategoryController::class);
+
+    // Media sub categories
+    Route::get('sub-categories/by-category/{categoryId}', [SubCategoryController::class, 'index']);
+    Route::apiResource('sub-categories', SubCategoryController::class);
+
 
 
     // Music Categories
@@ -166,6 +196,14 @@
     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']);
@@ -174,6 +212,7 @@
     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']);
@@ -191,4 +230,25 @@
         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']);
+    });
+
+
+    // Like routes (only for music and media)
+    Route::prefix('likes')->group(function () {
+        Route::post('/like', [LikeController::class, 'like']);
+        Route::post('/unlike', [LikeController::class, 'unlike']);
+        Route::post('/toggle', [LikeController::class, 'toggleLike']);
+        Route::get('/my-liked', [LikeController::class, 'myLikedItems']);
+        Route::post('/check', [LikeController::class, 'checkLiked']);
+        Route::get('/top-liked', [LikeController::class, 'topLiked']);
+    });
   });