fedi-feed-router/backend/app/Http/Controllers/Api/V1/RoutingController.php

<?php

namespace App\Http\Controllers\Api\V1;

use Domains\Feed\Resources\RouteResource;
use Domains\Feed\Models\Feed;
use Domains\Platform\Models\PlatformChannel;
use Domains\Feed\Models\Route;
use Domains\Feed\Requests\StoreRouteRequest;
use Domains\Feed\Requests\UpdateRouteRequest;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Validation\ValidationException;

class RoutingController extends BaseController
{
    /**
     * Display a listing of routing configurations
     */
    public function index(): JsonResponse
    {
        $routes = Route::with(['feed', 'platformChannel', 'language', 'keywords'])
            ->orderBy('is_active', 'desc')
            ->orderBy('priority', 'asc')
            ->get();

        return $this->sendResponse(
            RouteResource::collection($routes),
            'Routing configurations retrieved successfully.'
        );
    }

    /**
     * Store a newly created routing configuration
     */
    public function store(StoreRouteRequest $request): JsonResponse
    {
        try {
            $validated = $request->validated();

            $validated['is_active'] = $validated['is_active'] ?? true;
            $validated['priority'] = $validated['priority'] ?? 0;

            $route = Route::create($validated);

            return $this->sendResponse(
                new RouteResource($route->load(['feed', 'platformChannel', 'language', 'keywords'])),
                'Routing configuration created successfully!',
                201
            );
        } catch (ValidationException $e) {
            return $this->sendValidationError($e->errors());
        } catch (\Exception $e) {
            return $this->sendError('Failed to create routing configuration: ' . $e->getMessage(), [], 500);
        }
    }

    /**
     * Display the specified routing configuration
     */
    public function show(Feed $feed, PlatformChannel $channel): JsonResponse
    {
        $route = $this->findRoute($feed, $channel);
        
        if (!$route) {
            return $this->sendNotFound('Routing configuration not found.');
        }
        
        $route->load(['feed', 'platformChannel', 'language', 'keywords']);

        return $this->sendResponse(
            new RouteResource($route),
            'Routing configuration retrieved successfully.'
        );
    }

    /**
     * Update the specified routing configuration
     */
    public function update(UpdateRouteRequest $request, Feed $feed, PlatformChannel $channel): JsonResponse
    {
        try {
            $route = $this->findRoute($feed, $channel);

            if (!$route) {
                return $this->sendNotFound('Routing configuration not found.');
            }

            $validated = $request->validated();

            Route::where('feed_id', $feed->id)
                ->where('platform_channel_id', $channel->id)
                ->update($validated);

            return $this->sendResponse(
                new RouteResource($route->fresh(['feed', 'platformChannel', 'language', 'keywords'])),
                'Routing configuration updated successfully!'
            );
        } catch (ValidationException $e) {
            return $this->sendValidationError($e->errors());
        } catch (\Exception $e) {
            return $this->sendError('Failed to update routing configuration: ' . $e->getMessage(), [], 500);
        }
    }

    /**
     * Remove the specified routing configuration
     */
    public function destroy(Feed $feed, PlatformChannel $channel): JsonResponse
    {
        try {
            $route = $this->findRoute($feed, $channel);

            if (!$route) {
                return $this->sendNotFound('Routing configuration not found.');
            }

            Route::where('feed_id', $feed->id)
                ->where('platform_channel_id', $channel->id)
                ->delete();

            return $this->sendResponse(
                null,
                'Routing configuration deleted successfully!'
            );
        } catch (\Exception $e) {
            return $this->sendError('Failed to delete routing configuration: ' . $e->getMessage(), [], 500);
        }
    }

    /**
     * Toggle routing configuration active status
     */
    public function toggle(Feed $feed, PlatformChannel $channel): JsonResponse
    {
        try {
            $route = $this->findRoute($feed, $channel);

            if (!$route) {
                return $this->sendNotFound('Routing configuration not found.');
            }

            $newStatus = !$route->is_active;
            Route::where('feed_id', $feed->id)
                ->where('platform_channel_id', $channel->id)
                ->update(['is_active' => $newStatus]);

            $status = $newStatus ? 'activated' : 'deactivated';

            return $this->sendResponse(
                new RouteResource($route->fresh(['feed', 'platformChannel', 'language', 'keywords'])),
                "Routing configuration {$status} successfully!"
            );
        } catch (\Exception $e) {
            return $this->sendError('Failed to toggle routing configuration status: ' . $e->getMessage(), [], 500);
        }
    }

    /**
     * Find a route by feed and channel
     */
    private function findRoute(Feed $feed, PlatformChannel $channel): ?Route
    {
        return Route::where('feed_id', $feed->id)
            ->where('platform_channel_id', $channel->id)
            ->first();
    }
}