<?php

namespace App\Http\Controllers;

use App\Models\Media;
use App\Models\Category;
use App\Models\Tag;
use Illuminate\Support\Facades\DB;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;

class MediaController extends Controller
{
    // CREATE media
    public function store(Request $request)
    {
        $data = $request->validate([
            'title' => 'required|string|max:255',
            'caption' => 'nullable|string',
            'type' => 'required|in:audio,video',
            'category_id' => 'nullable|exists:categories,id',
            'category_name' => 'nullable|string|max:255',
            'image_id' => 'nullable|exists:images,id',
            'duration' => 'nullable|integer',
            'is_premium' => 'nullable|boolean',
            'file' => 'nullable|mimes:mp3,wav,mp4,mov|max:512000',
            'external_url' => 'nullable|string',
            'visibility' => 'nullable|in:public,private',

            'tags' => 'nullable|array',
             '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');
        }

        $media = Media::create([
            'user_id' => auth()->id(),
            'title' => $data['title'],
            'caption' => $data['caption'] ?? null,
            'type' => $data['type'],
            '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
        ]);
        if (!empty($data['tags'])) {
            $tagIds = [];

            foreach ($data['tags'] as $tagName) {
                $tag = Tag::firstOrCreate(['name' => $tagName]);
                $tagIds[] = $tag->id;
            }

            $media->tags()->sync($tagIds);
        }
        return response()->json([
            'message' => 'Media created successfully',
            'media' => $media->load(['image', 'category' , 'tags']),
        ]);
    }
public function index(Request $request)
{
    $query = Media::with(['image', 'category', 'myNote', 'tags'])
        ->where(function ($q) {
            $q->where('visibility', 'public')
              ->orWhere('user_id', auth()->id());
        });

    /*
    |--------------------------------------------------------------------------
    | 1️⃣ Multi Category
    |--------------------------------------------------------------------------
    */

    if ($request->filled('categories')) {
        $categories = explode(',', $request->categories);
        $query->whereIn('category_id', $categories);
    }

    /*
    |--------------------------------------------------------------------------
    | 2️⃣ Multi Duration Ranges
    |--------------------------------------------------------------------------
    | duration stored in minutes (integer)
    |--------------------------------------------------------------------------
    */

    if ($request->filled('durations')) {

        $ranges = explode(',', $request->durations);

        $query->where(function ($q) use ($ranges) {

            foreach ($ranges as $range) {

                if ($range === '1-2') {
                    $q->orWhereBetween('duration', [1, 2]);
                }

                if ($range === '2-5') {
                    $q->orWhereBetween('duration', [3, 5]);
                }

                if ($range === '5-10') {
                    $q->orWhereBetween('duration', [6, 10]);
                }
                if ($range === '10-30') {
                    $q->orWhereBetween('duration', [10, 30]);
                }
                if ($range === '30-60') {
                    $q->orWhereBetween('duration', [30, 60]);
                }
                 if ($range === '60-120') {
                    $q->orWhereBetween('duration', [60, 120]);
                }

                if ($range === 'other') {
                    $q->orWhere('duration', '>', 120);
                }
            }

        });
    }

    /*
    |--------------------------------------------------------------------------
    | 3️⃣ Tags
    |--------------------------------------------------------------------------
    */

    if ($request->filled('tags')) {
        $tags = explode(',', $request->tags);

        $query->whereHas('tags', function ($q) use ($tags) {
            $q->whereIn('name', $tags);
        });
    }

    /*
    |--------------------------------------------------------------------------
    | 4️⃣ Search
    |--------------------------------------------------------------------------
    */

    if ($request->filled('search')) {

        $search = $request->search;

        $query->where(function ($q) use ($search) {

            $q->where('title', 'LIKE', "%$search%")
              ->orWhere('caption', 'LIKE', "%$search%")
              ->orWhereHas('category', function ($c) use ($search) {
                  $c->where('name', 'LIKE', "%$search%");
              })
              ->orWhereHas('tags', function ($t) use ($search) {
                  $t->where('name', 'LIKE', "%$search%");
              });

        });
    }

    return response()->json(
        $query->orderBy('created_at', 'desc')->get()
    );
}

public function filters(Request $request)
{
    $baseQuery = Media::query()
        ->where(function ($q) {
            $q->where('visibility', 'public')
              ->orWhere('user_id', auth()->id());
        });

    /*
    |--------------------------------------------------------------------------
    | 1️⃣ Categories with media count
    |--------------------------------------------------------------------------
    */

    $categories = Category::select(
            'categories.id',
            'categories.name',
            DB::raw('COUNT(media.id) as media_count')
        )
        ->leftJoin('media', function ($join) {
            $join->on('categories.id', '=', 'media.category_id')
                ->where(function ($q) {
                    $q->where('media.visibility', 'public')
                      ->orWhere('media.user_id', auth()->id());
                });
        })
        ->groupBy('categories.id', 'categories.name')
        ->orderByDesc('media_count')
        ->get();


    /*
    |--------------------------------------------------------------------------
    | 2️⃣ Duration ranges
    |--------------------------------------------------------------------------
    | duration is stored in seconds
    |--------------------------------------------------------------------------
    */

    $durations = Media::select(
            DB::raw("
                CASE
                    WHEN duration BETWEEN 1 AND 2 THEN '1-2'
                    WHEN duration BETWEEN 3 AND 5 THEN '2-5'
                    WHEN duration BETWEEN 5 AND 10 THEN '5-10'
                    WHEN duration BETWEEN 10 AND 20 THEN '10-20'
                    WHEN duration BETWEEN 20 AND 30 THEN '20-30'
                    WHEN duration BETWEEN 60 AND 120 THEN '60-120'
                    ELSE 'other'
                END as duration_range
            "),
            DB::raw('COUNT(*) as total')
        )
        ->whereNotNull('duration')
        ->where(function ($q) {
            $q->where('visibility', 'public')
              ->orWhere('user_id', auth()->id());
        })
        ->groupBy('duration_range')
        ->get();

    return response()->json([
        'categories' => $categories,
        'durations'  => $durations,
    ]);
}

    public function show($id)
    {
     $media = Media::with(['image', 'category', 'myNote', 'tags'])
        ->where('id', $id)
        ->where(function($query) {
            $query->where('visibility', 'public')
                  ->orWhere('user_id', auth()->id());
        })
        ->firstOrFail();

         return response()->json([
        'id' => $media->id,
        'title' => $media->title,
        'caption' => $media->caption,
        'type' => $media->type,
        'file_path' => $media->file_path,
        'external_url' => $media->external_url,
        'duration' => $media->duration,
        'visibility' => $media->visibility,
        'created_at' => $media->created_at,
        'updated_at' => $media->updated_at,
        'image' => $media->image,
        'category' => $media->category,
        'tags' => $media->tags,
        'myNote' => $media->myNote,
        'is_saved' => $media->is_saved,
        'is_premium' => $media->is_premium,
    ]);
    }

    // UPDATE media
public function update(Request $request, $id)
{
    $media = Media::where('id', $id)
        ->where('user_id', auth()->id())
        ->firstOrFail();

    $data = $request->validate([
        'title' => 'nullable|string',
        'caption' => 'nullable|string',
        'type' => 'nullable|in:audio,video',

        // support both: category_id or category_name
        'category_id' => 'nullable|exists:categories,id',
        'category_name' => 'nullable|string|max:255',
        'is_premium' => 'nullable|boolean',
        'image_id' => 'nullable|exists:images,id',
        'duration' => 'nullable|integer',
        'file' => 'nullable|mimes:mp3,wav,mp4,mov|max:512000',
        'external_url' => 'nullable|string',
        'visibility' => 'nullable|in:public,private',
        'tags' => 'nullable|array',
        '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);
        $data['file_path'] = $request->file('file')->store('media', 'public');
    }

    // --- Prepare update data ---
    $updateData = [
        '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,
        'visibility' => $data['visibility'] ?? $media->visibility,
        'file_path' => $data['file_path'] ?? $media->file_path,
    ];

    // --- Handle image_id specifically ---
    // If image_id is provided in request, use it (even if null to remove association)
    // If not provided, keep the existing value
    if (array_key_exists('image_id', $data)) {
        $updateData['image_id'] = $data['image_id'];
    } else {
        $updateData['image_id'] = $media->image_id;
    }

    // --- update media ---
    $media->update($updateData);

    if (isset($data['tags'])) {
        $tagIds = [];

        foreach ($data['tags'] as $tagName) {
            $tag = Tag::firstOrCreate(['name' => $tagName]);
            $tagIds[] = $tag->id;
        }

        $media->tags()->sync($tagIds);
    }

    return response()->json([
        'message' => 'Media updated successfully',
        'media' => $media->load(['image', 'category' , 'tags']),
    ]);
}


    public function destroy($id)
    {
        $media = Media::where('id', $id)
            ->where('user_id', auth()->id())
            ->firstOrFail();

        Storage::disk('public')->delete($media->file_path);

        $media->delete();

        return response()->json(['message' => 'Media deleted']);
    }

    // SAVE media
public function toggleSaveMedia($id)
{
    $user = auth()->user();

    if ($user->savedMedia()->where('media_id', $id)->exists()) {
        // already saved → unsave
        $user->savedMedia()->detach($id);
        return response()->json(['message' => 'Unsaved!']);
    } else {
        // not saved → save
        $user->savedMedia()->attach($id);
        return response()->json(['message' => 'Saved!']);
    }
}

    // GET saved
    public function saved()
    {
        return auth()->user()->savedMedia()->with(['image','category' , 'myNote' , 'tags'])->get();
    }

public function storeNote(Request $request, $mediaId)
{
    $media = Media::findOrFail($mediaId);
    $userId = auth()->id();

    $content = $request->input('content');

    // Check if note already exists for this user
    $note = $media->notes()->where('user_id', $userId)->first();

    if (empty($content)) {
        // If content is empty, delete the note if it exists
        if ($note) {
            $note->delete();
            return response()->json(['message' => 'Note deleted']);
        }
        return response()->json(['message' => 'No note to delete']);
    }

    if ($note) {
        // Update existing note
        $note->update(['content' => $content]);
    } else {
        // Create new note
        $note = $media->notes()->create([
            'user_id' => $userId,
            'content' => $content,
        ]);
    }

    return response()->json([
        'message' => 'Note saved successfully',
        'note' => $note
    ]);
}

}