<?php

namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Models\Topic;
use App\Models\TopicCategory;
use App\Models\TopicTag;
use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Str;
use Inertia\Inertia;

class ForumTopicController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index(Request $request)
    {
        $search = $request->input('search');
        $status = $request->input('status');
        $category = $request->input('category');
        $priority = $request->input('priority');
        $perPage = $request->input('per_page', 10);

        $topics = Topic::with(['user', 'categories', 'tags'])
            ->when($search, function ($query, $search) {
                return $query->where('title', 'like', "%{$search}%")
                    ->orWhere('content', 'like', "%{$search}%");
            })
            ->when($status, function ($query, $status) {
                return $query->where('status', $status);
            })
            ->when($priority, function ($query, $priority) {
                return $query->where('priority', $priority);
            })
            ->when($category, function ($query, $category) {
                return $query->whereHas('categories', function ($q) use ($category) {
                    $q->where('topic_categories.id', $category);
                });
            });

        // Check permissions
        $user = Auth::user();
        if (!$user->can('topics.view')) {
            $topics->where('user_id', $user->id);
        }

        $topics = $topics->orderBy('created_at', 'desc')->paginate($perPage);
        $categories = TopicCategory::where('is_active', true)->get();
        $statusOptions = ['draft', 'published', 'resolved', 'rejected'];
        $priorityOptions = ['normal', 'urgent'];

        return Inertia::render('admin/forum/topics/Index', [
            'topics' => $topics,
            'categories' => $categories,
            'statusOptions' => $statusOptions,
            'priorityOptions' => $priorityOptions,
            'filters' => [
                'search' => $search,
                'status' => $status,
                'category' => $category,
                'priority' => $priority,
                'per_page' => $perPage,
            ],
        ]);
    }

    /**
     * Show the form for creating a new resource.
     */
    public function create()
    {
        $categories = TopicCategory::where('is_active', true)->orderBy('sort_order')->get();
        $tags = TopicTag::orderBy('name')->get();

        return Inertia::render('admin/forum/topics/Create', [
            'categories' => $categories,
            'tags' => $tags,
        ]);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validated = $request->validate([
            'title' => 'required|string|max:255',
            'slug' => 'nullable|string|max:255',
            'short_description' => 'nullable|string|max:500',
            'content' => 'required|string',
            'status' => 'required|in:draft,published,resolved,rejected',
            'priority' => 'required|in:normal,urgent',
            'comment_permission' => 'required|in:all,experts_only,users_only,closed',
            'is_featured' => 'boolean',
            'is_pinned' => 'boolean',
            'categories' => 'required|array|min:1',
            'categories.*' => 'exists:topic_categories,id',
            'tags' => 'nullable|array',
            'tags.*' => 'string|max:255',
        ]);

        // Check permissions
        $user = Auth::user();
        if (!$user->can('topics.create')) {
            abort(403);
        }

        // Generate slug if not provided
        if (empty($validated['slug'])) {
            $validated['slug'] = Str::slug($validated['title']);
            // Ensure unique slug
            $originalSlug = $validated['slug'];
            $count = 1;
            while (Topic::where('slug', $validated['slug'])->exists()) {
                $validated['slug'] = $originalSlug . '-' . $count;
                $count++;
            }
        } else {
            // Check if slug already exists
            if (Topic::where('slug', $validated['slug'])->exists()) {
                return back()->withErrors(['slug' => 'URL already exists.']);
            }
        }

        // Set current user as author
        $validated['user_id'] = auth()->id();

        // Check status permissions
        if (in_array($validated['status'], ['published']) && 
            !$user->can('topics.publish')) {
            $validated['status'] = 'draft';
        }

        // Create topic
        $topic = Topic::create($validated);

        // Attach categories
        if (!empty($validated['categories'])) {
            $topic->categories()->attach($validated['categories']);
        }

        // Process tags
        if (!empty($validated['tags'])) {
            $tagIds = [];
            foreach ($validated['tags'] as $tagName) {
                $tag = TopicTag::firstOrCreate(
                    ['slug' => Str::slug($tagName)],
                    ['name' => $tagName]
                );
                $tag->increment('usage_count');
                $tagIds[] = $tag->id;
            }
            $topic->tags()->attach($tagIds);
        }

        return redirect()->route('admin.forum.topics.index')
            ->with('success', 'Topic created successfully.');
    }

    /**
     * Display the specified resource.
     */
    public function show(Topic $topic)
    {
        // Check permissions
        $user = Auth::user();
        if (!$user->can('topics.view') && $topic->user_id !== $user->id) {
            abort(403);
        }

        $topic->load(['user', 'categories', 'tags', 'comments.user']);

        return Inertia::render('admin/forum/topics/Show', [
            'topic' => $topic,
        ]);
    }

    /**
     * Show the form for editing the specified resource.
     */
    public function edit(Topic $topic)
    {
        // Check permissions
        $user = Auth::user();
        if (!$user->can('topics.edit') && 
            (!$user->can('topics.owner.edit') || $topic->user_id !== $user->id)) {
            abort(403);
        }

        $topic->load(['categories', 'tags']);
        $categories = TopicCategory::where('is_active', true)->orderBy('sort_order')->get();
        $tags = TopicTag::orderBy('name')->get();

        return Inertia::render('admin/forum/topics/Edit', [
            'topic' => $topic,
            'categories' => $categories,
            'tags' => $tags,
        ]);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, Topic $topic)
    {
        // Check permissions
        $user = Auth::user();
        if (!$user->can('topics.edit') && 
            (!$user->can('topics.owner.edit') || $topic->user_id !== $user->id)) {
            abort(403);
        }

        $validated = $request->validate([
            'title' => 'required|string|max:255',
            'slug' => 'nullable|string|max:255',
            'short_description' => 'nullable|string|max:500',
            'content' => 'required|string',
            'status' => 'required|in:draft,published,resolved,rejected',
            'priority' => 'required|in:normal,urgent',
            'comment_permission' => 'required|in:all,experts_only,users_only,closed',
            'is_featured' => 'boolean',
            'is_pinned' => 'boolean',
            'categories' => 'required|array|min:1',
            'categories.*' => 'exists:topic_categories,id',
            'tags' => 'nullable|array',
            'tags.*' => 'string|max:255',
        ]);

        // Check slug uniqueness if changed
        if (!empty($validated['slug']) && $validated['slug'] !== $topic->slug) {
            if (Topic::where('slug', $validated['slug'])->where('id', '!=', $topic->id)->exists()) {
                return back()->withErrors(['slug' => 'URL already exists.']);
            }
        }

        // Check status permissions
        if (in_array($validated['status'], ['published']) && 
            $topic->status !== 'published' &&
            !$user->can('topics.publish')) {
            unset($validated['status']);
        }

        // Update topic
        $topic->update($validated);

        // Sync categories
        $topic->categories()->sync($validated['categories']);

        // Process tags
        if (isset($validated['tags'])) {
            // Decrement usage count for removed tags
            $oldTagIds = $topic->tags->pluck('id')->toArray();
            
            $tagIds = [];
            foreach ($validated['tags'] as $tagName) {
                $tag = TopicTag::firstOrCreate(
                    ['slug' => Str::slug($tagName)],
                    ['name' => $tagName]
                );
                if (!in_array($tag->id, $oldTagIds)) {
                    $tag->increment('usage_count');
                }
                $tagIds[] = $tag->id;
            }

            // Decrement count for removed tags
            $removedTagIds = array_diff($oldTagIds, $tagIds);
            TopicTag::whereIn('id', $removedTagIds)->decrement('usage_count');

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

        return redirect()->route('admin.forum.topics.index')
            ->with('success', 'Topic updated successfully.');
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Topic $topic)
    {
        // Check permissions
        $user = Auth::user();
        if (!$user->can('topics.delete') && 
            (!$user->can('topics.owner.delete') || $topic->user_id !== $user->id)) {
            abort(403);
        }

        // Decrement tag usage count
        $topic->tags()->decrement('usage_count');

        $topic->delete();

        return redirect()->route('admin.forum.topics.index')
            ->with('success', 'Topic deleted successfully.');
    }

    /**
     * Restore the specified resource.
     */
    public function restore($id)
    {
        // Check permissions
        $user = Auth::user();
        if (!$user->can('topics.manager')) {
            abort(403);
        }

        $topic = Topic::withTrashed()->findOrFail($id);
        $topic->restore();

        // Re-increment tag usage count
        $topic->tags()->increment('usage_count');

        return redirect()->route('admin.forum.topics.index')
            ->with('success', 'Topic restored successfully.');
    }

    /**
     * Permanently delete the specified resource.
     */
    public function forceDelete($id)
    {
        // Check permissions
        $user = Auth::user();
        if (!$user->can('topics.manager')) {
            abort(403);
        }

        $topic = Topic::withTrashed()->findOrFail($id);
        $topic->forceDelete();

        return redirect()->route('admin.forum.topics.index')
            ->with('success', 'Topic permanently deleted.');
    }
}