<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Concerns\ResolvesActiveUnit;
use App\Enums\NotificationType;
use App\Services\KanbanService;
use App\Services\NotificationService;
use App\Http\Requests\KanbanRequest;
use App\Http\Requests\KanbanReorderRequest;
use App\Http\Resources\KanbanResource;
use App\Models\Unit;
use Illuminate\Http\JsonResponse;

class KanbanController extends Controller
{
    use ResolvesActiveUnit;

    public function __construct(
        protected KanbanService $service,
        protected NotificationService $notifications,
    ) {}

    public function index(): JsonResponse
    {
        $user = auth()->user();

        if ($this->isMatriz($user)) {
            $items = $this->service->getAll();
        } else {
            $items = $this->service->getAllForUnit($this->activeUnitId($user));
        }

        return $this->successResponse(payload: KanbanResource::collection($items));
    }

    public function store(KanbanRequest $request): JsonResponse
    {
        $data = $request->validated();
        $user = auth()->user();
        $isMatriz = $this->isMatriz($user);

        $data['origin'] = $isMatriz ? 'matriz' : 'unit';
        $data['created_by_user_id'] = $user->id;
        $data['unit_id'] = $isMatriz ? null : $this->activeUnitId($user);

        // Broadcast to all units
        if ($isMatriz && ($data['scope'] ?? null) === 'all') {
            $unitIds = Unit::query()->pluck('id');
            $created = [];
            foreach ($unitIds as $unitId) {
                $card = $this->service->create(array_merge($data, [
                    'target_unit_id' => $unitId,
                ]));
                $this->notifyKanbanCreated($card);
                $created[] = $card;
            }
            return $this->successResponse(
                payload: KanbanResource::collection($created),
                message: __('messages.created'),
                code: 201
            );
        }

        if ($isMatriz) {
            if (($data['scope'] ?? null) === 'internal') {
                $data['target_unit_id'] = null;
            }
            // scope='specific' → target_unit_id already set from request
        } else {
            // Franchisee: internal = own unit, specific = Matriz (null target)
            $data['target_unit_id'] = (($data['scope'] ?? null) === 'internal')
                ? $this->activeUnitId($user)
                : null;
        }

        $item = $this->service->create($data);
        $this->notifyKanbanCreated($item);
        return $this->successResponse(
            payload: new KanbanResource($item),
            message: __('messages.created'),
            code: 201
        );
    }

    /**
     * Notifica o outro lado quando uma atividade é criada:
     * franqueada → matriz; matriz → unidade alvo.
     */
    private function notifyKanbanCreated(\App\Models\Kanban $card): void
    {
        if ($card->origin === 'unit') {
            $unitId     = $card->unit_id;
            $recipients = $this->notifications->matrizUserIds();
        } else {
            $unitId     = $card->target_unit_id;
            $recipients = $this->notifications->unitUserIds($unitId);
        }

        $this->notifications->dispatch([
            'origin_table'       => 'kanbans',
            'origin_id'          => $card->id,
            'unit_id'            => $unitId,
            'type'               => NotificationType::KANBAN_CREATED->value,
            'title'              => 'Nova atividade',
            'message'            => $card->title,
            'url'                => '/kanban',
            'action_text'        => 'Ver atividade',
            'priority'           => $card->priority === 'alta' ? 'high' : 'normal',
            'created_by_user_id' => $card->created_by_user_id,
            'recipient_user_ids' => $recipients,
        ]);
    }

    public function show(int $id): JsonResponse
    {
        $item = $this->service->findById($id);
        return $this->successResponse(payload: new KanbanResource($item));
    }

    public function update(KanbanRequest $request, int $id): JsonResponse
    {
        $item = $this->service->update($id, $request->validated());
        return $this->successResponse(payload: new KanbanResource($item), message: __('messages.updated'));
    }

    public function destroy(int $id): JsonResponse
    {
        $this->service->delete($id);
        return $this->successResponse(message: __('messages.deleted'), code: 204);
    }

    public function reorder(KanbanReorderRequest $request): JsonResponse
    {
        $this->service->reorder($request->validated()['items']);
        return $this->successResponse(message: __('messages.updated'));
    }

    private function isMatriz(\App\Models\User $user): bool
    {
        return $user->user_type === 'ADMIN';
    }
}