<?php

namespace App\Http\Controllers;

use App\Models\Task;
use App\Models\User;
use App\Http\Requests\StoreTaskRequest;
use App\Http\Requests\UpdateTaskRequest;
use Illuminate\Http\Request;
use Inertia\Inertia;
use Inertia\Response;

class TaskController extends Controller
{
    /**
     * Display a listing of tasks.
     */
    public function index(Request $request): Response
    {
        $user = auth()->user();
        
        $query = Task::with(['assignee:id,member,email,role', 'creator:id,member,email,role']);

        // Filter based on user role
        if ($user->role === 'staff') {
            // Staff can only see tasks assigned to them
            $query->where('assigned_to', $user->id);
        } elseif ($user->role === 'admin') {
            // Admin can see tasks assigned to them or created by them
            $query->where(function ($q) use ($user) {
                $q->where('assigned_to', $user->id)
                  ->orWhere('created_by', $user->id);
            });
        }
        // Superadmin can see all tasks

        // Apply filters
        if ($request->filled('status')) {
            $query->where('status', $request->status);
        }

        if ($request->filled('priority')) {
            $query->where('priority', $request->priority);
        }

        if ($request->filled('assigned_to')) {
            $query->where('assigned_to', $request->assigned_to);
        }

        if ($request->filled('search')) {
            $search = $request->search;
            $query->where(function ($q) use ($search) {
                $q->where('title', 'like', "%{$search}%")
                  ->orWhere('description', 'like', "%{$search}%");
            });
        }

        // Sort by priority (urgent first) and due date
        $query->orderByRaw("FIELD(priority, 'urgent', 'high', 'medium', 'low')")
              ->orderBy('due_date', 'asc')
              ->orderBy('created_at', 'desc');

        $tasks = $query->paginate(15)->withQueryString();

        // Get stats for dashboard
        $stats = $this->getTaskStats($user);

        return Inertia::render('TaskManager/Index', [
            'tasks' => $tasks,
            'stats' => $stats,
            'filters' => $request->only(['status', 'priority', 'assigned_to', 'search']),
            'priorities' => Task::getPriorities(),
            'statuses' => Task::getStatuses(),
        ]);
    }

    /**
     * Show the form for creating a new task.
     */
    public function create(): Response
    {
        $user = auth()->user();
        
        // Only admin and superadmin can create tasks
        if (!in_array($user->role, ['admin', 'superadmin'])) {
            abort(403, 'Unauthorized');
        }

        // Get staff and admin users for assignment
        $assignableUsers = User::whereIn('role', ['admin', 'staff'])
            ->orderBy('member')
            ->get(['id', 'member', 'email', 'role']);

        return Inertia::render('TaskManager/Create', [
            'assignableUsers' => $assignableUsers,
            'priorities' => Task::getPriorities(),
            'statuses' => Task::getStatuses(),
        ]);
    }

    /**
     * Store a newly created task.
     */
    public function store(StoreTaskRequest $request)
    {
        $task = Task::create([
            ...$request->validated(),
            'created_by' => auth()->id(),
        ]);

        return redirect()->route('task-manager.show', $task->id)
            ->with('success', 'Task created successfully.');
    }

    /**
     * Display the specified task.
     */
    public function show(Task $task): Response
    {
        $user = auth()->user();

        // Check if user can view this task
        if (!$this->canViewTask($user, $task)) {
            abort(403, 'Unauthorized');
        }

        $task->load(['assignee:id,member,email,role', 'creator:id,member,email,role']);

        return Inertia::render('TaskManager/Show', [
            'task' => $task,
            'priorities' => Task::getPriorities(),
            'statuses' => Task::getStatuses(),
        ]);
    }

    /**
     * Show the form for editing the specified task.
     */
    public function edit(Task $task): Response
    {
        $user = auth()->user();

        // Check if user can edit this task
        if (!$this->canEditTask($user, $task)) {
            abort(403, 'Unauthorized');
        }

        $task->load(['assignee:id,member,email,role', 'creator:id,member,email,role']);

        $assignableUsers = User::whereIn('role', ['admin', 'staff'])
            ->orderBy('member')
            ->get(['id', 'member', 'email', 'role']);

        return Inertia::render('TaskManager/Edit', [
            'task' => $task,
            'assignableUsers' => $assignableUsers,
            'priorities' => Task::getPriorities(),
            'statuses' => Task::getStatuses(),
        ]);
    }

    /**
     * Update the specified task.
     */
    public function update(UpdateTaskRequest $request, Task $task)
    {
        $data = $request->validated();

        // If status is being changed to completed, set completed_at
        if ($data['status'] === Task::STATUS_COMPLETED && $task->status !== Task::STATUS_COMPLETED) {
            $data['completed_at'] = now();
        } elseif ($data['status'] !== Task::STATUS_COMPLETED) {
            $data['completed_at'] = null;
        }

        $task->update($data);

        return redirect()->route('task-manager.show', $task->id)
            ->with('success', 'Task updated successfully.');
    }

    /**
     * Remove the specified task.
     */
    public function destroy(Task $task)
    {
        $user = auth()->user();

        // Only superadmin and task creator can delete
        if ($user->role !== 'superadmin' && $task->created_by !== $user->id) {
            abort(403, 'Unauthorized');
        }

        $task->delete();

        return redirect()->route('task-manager.index')
            ->with('success', 'Task deleted successfully.');
    }

    /**
     * Update task status quickly (AJAX endpoint)
     */
    public function updateStatus(Request $request, Task $task)
    {
        $user = auth()->user();

        if (!$this->canEditTask($user, $task)) {
            abort(403, 'Unauthorized');
        }

        $request->validate([
            'status' => 'required|in:pending,in_progress,completed,cancelled',
        ]);

        $data = ['status' => $request->status];

        if ($request->status === Task::STATUS_COMPLETED) {
            $data['completed_at'] = now();
        } else {
            $data['completed_at'] = null;
        }

        $task->update($data);

        return back()->with('success', 'Task status updated.');
    }

    /**
     * Get task statistics for dashboard
     */
    private function getTaskStats($user): array
    {
        $baseQuery = Task::query();

        if ($user->role === 'staff') {
            $baseQuery->where('assigned_to', $user->id);
        } elseif ($user->role === 'admin') {
            $baseQuery->where(function ($q) use ($user) {
                $q->where('assigned_to', $user->id)
                  ->orWhere('created_by', $user->id);
            });
        }

        return [
            'total' => (clone $baseQuery)->count(),
            'pending' => (clone $baseQuery)->where('status', 'pending')->count(),
            'in_progress' => (clone $baseQuery)->where('status', 'in_progress')->count(),
            'completed' => (clone $baseQuery)->where('status', 'completed')->count(),
            'overdue' => (clone $baseQuery)->overdue()->count(),
        ];
    }

    /**
     * Check if user can view a task
     */
    private function canViewTask($user, Task $task): bool
    {
        if ($user->role === 'superadmin') {
            return true;
        }

        if ($user->role === 'admin') {
            return $task->assigned_to === $user->id || $task->created_by === $user->id;
        }

        if ($user->role === 'staff') {
            return $task->assigned_to === $user->id;
        }

        return false;
    }

    /**
     * Check if user can edit a task
     */
    private function canEditTask($user, Task $task): bool
    {
        if ($user->role === 'superadmin') {
            return true;
        }

        if ($user->role === 'admin') {
            return $task->created_by === $user->id;
        }

        // Staff can only update status of their own tasks
        if ($user->role === 'staff') {
            return $task->assigned_to === $user->id;
        }

        return false;
    }
}