nginx:
  image: nginx:alpine
  container_name: nginx_chat
  restart: unless-stopped
  depends_on:
    - app
  volumes:
    - ./src:/var/www
    - ./nginx/conf.d/default.conf:/etc/nginx/conf.d/default.conf
    - ./nginx/nginx.conf:/etc/nginx/nginx.conf
  networks:
    - proxy-network

app:
  build:
    context: .
    dockerfile: ./app/Dockerfile
  container_name: app_chat
  working_dir: /var/www
  restart: unless-stopped
  depends_on:
    - database
    - node
  environment:
    DB_DATABASE: ${DB_DATABASE}
    DB_USERNAME: ${DB_USER}
    DB_PASSWORD: ${DB_PASSWORD}
    DB_HOST: database
  volumes:
    - ./src:/var/www
  networks:
    - mysql-network

  queue-worker:
    build:
      context: .
      dockerfile: ./app/Dockerfile
    container_name: queue_chat
    working_dir: /var/www
    command: php artisan queue:work
    restart: unless-stopped
    depends_on:
      - app
    environment:
      DB_DATABASE: ${DB_DATABASE}
      DB_USERNAME: ${DB_USER}
      DB_PASSWORD: ${DB_PASSWORD}
      DB_HOST: database
    volumes:
      - ./src:/var/www
    networks:
      - mysql-network

  reverb-server:
    build:
      context: .
      dockerfile: ./app/Dockerfile
    container_name: reverb_chat
    working_dir: /var/www
    command: php artisan reverb:start --debug
    restart: unless-stopped
    depends_on:
      - app
    environment:
      DB_DATABASE: ${DB_DATABASE}
      DB_USERNAME: ${DB_USER}
      DB_PASSWORD: ${DB_PASSWORD}
      DB_HOST: database
    volumes:
      - ./src:/var/www
    networks:
      - mysql-network

  node:
    image: node:18
    container_name: node_chat
    working_dir: /app
    volumes:
      - ./src:/app
    command: sh -c "npm install && npm run build"

  database:
    image: mariadb:latest
    container_name: database_chat
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_USER: ${DB_USER}
      MYSQL_PASSWORD: ${DB_PASSWORD}
    volumes:
      - db-data:/var/lib/mysql
    networks:
      - mysql-network

  phpmyadmin:
    image: phpmyadmin:5.2
    container_name: phpmyadmin_chat
    restart: unless-stopped
    environment:
      PMA_HOST: ${PMA_HOST}
      PMA_USER: ${PMA_USER}
      PMA_PASSWORD: ${PMA_PASSWORD}
    ports:
      - "8080:80"
    networks:
      - mysql-network
    depends_on:
      - database

public function rules(): array
{
    return [
        'message' => 'nullable|string',
        'group_id' => 'required_without:receiver_id|nullable|exists:groups,id',
        'receiver_id' => 'required_without:group_id|nullable|exists:users,id',
        'attachments' => 'nullable|array|max:10',
        'attachments.*' => 'file|max:1024000',
        'keys' => 'nullable|array',
        'keys.*' => 'required|string',
    ];
}

public function rules(): array
{
    return [
        'name' => ['required', 'string', 'max:255'],
        'description' => ['nullable', 'string'],
        'user_ids' => ['nullable', 'array'],
        'user_ids.*' => ['integer', 'exists:users,id'],
    ];
}

public function validated($key = null, $default = null)
{
    $validated = parent::validated($key, $default);
    $validated['owner_id'] = $this->user()->id;
    return $validated;
}

public function store(StoreGroupRequest $request)
{
    $data = $request->validated();
    $user_ids = $data['user_ids'] ?? [];

    $group = Group::create($data);
    $group->users()->attach(array_unique([$request->user()->id, ...$user_ids]));

    return redirect()->back();
}

public function destroy(Group $group)
{
    if ($group->owner_id !== auth()->id()) {
        abort(403);
    }

    DeleteGroupJob::dispatch($group)->delay(now()->addSeconds(10));

    return response()->json(['message' => 'Group delete was scheduled and will be deleted soon']);
}

public function destroy(Message $message)
{
    if ($message->sender_id !== auth()->id()) {
        return response()->json(['message' => 'Forbidden'], 403);
    }

    // Eliminar claves cifradas asociadas
    $message->keys()->delete();

    // Eliminar cada archivo físico y su registro
    $message->attachments()->each(function ($attachment) {
        Storage::disk('public')->delete($attachment->path);
        $attachment->delete();
    });

    // Eliminar el mensaje (esto dispara el observer)
    $message->delete();

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

public function deleting(Message $message)
{
    // Eliminar carpetas de adjuntos
    $message->attachments->each(function ($attachment) {
        Storage::disk('public')->deleteDirectory(dirname($attachment->path));
    });

    // Eliminar registros de adjuntos (refuerzo)
    $message->attachments()->delete();

    // Si es mensaje de grupo, actualizar el last_message_id
    if ($message->group_id) {
        $group = Group::where('last_message_id', $message->id)->first();
        if ($group) {
            $prev = Message::where('group_id', $group->id)
                ->where('id', '!=', $message->id)
                ->latest()
                ->first();
            if ($prev) {
                $group->last_message_id = $prev->id;
                $group->save();
            }
        }
    }
    // Si es conversación individual, hacer lo mismo
    else {
        $conversation = Conversation::where('last_message_id', $message->id)->first();
        if ($conversation) {
            $prev = Message::where(function ($q) use ($message) {
                    $q->where('sender_id', $message->sender_id)
                      ->where('receiver_id', $message->receiver_id)
                      ->orWhere('sender_id', $message->receiver_id)
                      ->where('receiver_id', $message->sender_id);
                })
                ->where('id', '!=', $message->id)
                ->latest()
                ->first();
            if ($prev) {
                $conversation->last_message_id = $prev->id;
                $conversation->save();
            }
        }
    }
}

public static function updateConversationWithMessage($userId1, $userId2, $message)
{
    $conversation = self::where(function ($query) use ($userId1, $userId2) {
        $query->where('user_id1', $userId1)
              ->where('user_id2', $userId2);
    })->orWhere(function ($query) use ($userId1, $userId2) {
        $query->where('user_id1', $userId2)
              ->where('user_id2', $userId1);
    })->first();

    if ($conversation) {
        $conversation->update([
            'last_message_id' => $message->id,
        ]);
    } else {
        self::create([
            'user_id1' => $userId1,
            'user_id2' => $userId2,
            'last_message_id' => $message->id,
        ]);
    }
}

public static function updateGroupWithMessage($groupId, $message)
{
    return self::updateOrCreate(
        ['id' => $groupId],
        ['last_message_id' => $message->id]
    );
}

useEffect(() => {
    const observer = new IntersectionObserver(
        (entries) =>
            entries.forEach((entry) => entry.isIntersecting && loadMoreMessages()),
        { rootMargin: "0px 0px 250px 0px" }
    );

    if (loadMoreIntersect.current) {
        setTimeout(() => observer.observe(loadMoreIntersect.current), 100);
    }

    return () => observer.disconnect();
}, [localMessages]);