CustomerPluginController.php

<?php

namespace App\Http\Controllers;

use App\Enums\PluginStatus;
use App\Features\AllowPaidPlugins;
use App\Http\Requests\SubmitPluginRequest;
use App\Http\Requests\UpdatePluginDescriptionRequest;
use App\Http\Requests\UpdatePluginLogoRequest;
use App\Jobs\ReviewPluginRepository;
use App\Models\Plugin;
use App\Notifications\PluginSubmitted;
use App\Services\GitHubUserService;
use App\Services\PluginSyncService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Storage;
use Illuminate\View\View;
use Laravel\Pennant\Feature;

class CustomerPluginController extends Controller
{
    public function __construct()
    {
        $this->middleware('auth');
    }

    public function index(): View
    {
        $user = Auth::user();
        $plugins = $user->plugins()->orderBy('created_at', 'desc')->get();
        $developerAccount = $user->developerAccount;

        return view('customer.plugins.index', compact('plugins', 'developerAccount'));
    }

    public function create(): View
    {
        $developerAccount = Auth::user()->developerAccount;

        return view('customer.plugins.create', [
            'hasAcceptedTerms' => $developerAccount?->hasAcceptedCurrentTerms() ?? false,
            'hasCompletedOnboarding' => $developerAccount?->hasCompletedOnboarding() ?? false,
        ]);
    }

    public function store(SubmitPluginRequest $request, PluginSyncService $syncService): RedirectResponse
    {
        $user = Auth::user();

        // Require developer onboarding and terms acceptance for all plugin submissions
        $developerAccount = $user->developerAccount;

        if (! $developerAccount || ! $developerAccount->hasAcceptedCurrentTerms()) {
            return to_route('customer.developer.onboarding')
                ->with('message', 'You must accept the Plugin Developer Terms and Conditions before submitting a plugin.');
        }

        // Reject paid plugin submissions if the feature is disabled
        if ($request->type === 'paid' && ! Feature::active(AllowPaidPlugins::class)) {
            return to_route('customer.plugins.create')
                ->with('error', 'Paid plugin submissions are not currently available.');
        }

        // For paid plugins, link to the user's developer account if they have one
        $developerAccountId = null;
        if ($request->type === 'paid' && $user->developerAccount) {
            $developerAccountId = $user->developerAccount->id;
        }

        // Build the full repository URL from vendor/repo format
        $repository = trim($request->repository, '/');
        $repositoryUrl = 'https://github.com/'.$repository;
        [$owner, $repo] = explode('/', $repository);

        $plugin = $user->plugins()->create([
            'repository_url' => $repositoryUrl,
            'type' => $request->type,
            'status' => PluginStatus::Pending,
            'developer_account_id' => $developerAccountId,
        ]);

        $webhookSecret = $plugin->generateWebhookSecret();

        // Attempt to automatically install the webhook if the user has a GitHub token
        $webhookInstalled = false;
        if ($user->hasGitHubToken()) {
            $githubService = GitHubUserService::for($user);
            $webhookResult = $githubService->createWebhook(
                $owner,
                $repo,
                $plugin->getWebhookUrl(),
                $webhookSecret
            );
            $webhookInstalled = $webhookResult['success'];
        }

        $plugin->update(['webhook_installed' => $webhookInstalled]);

        $syncService->sync($plugin);

        (new ReviewPluginRepository($plugin))->handle();

        if (! $plugin->name) {
            $plugin->delete();

            return to_route('customer.plugins.create')
                ->with('error', 'Could not find a valid composer.json in the repository. Please ensure your repository contains a composer.json with a valid package name.');
        }

        // Check if the vendor namespace is available for this user
        $namespace = $plugin->getVendorNamespace();
        if ($namespace && ! Plugin::isNamespaceAvailableForUser($namespace, $user->id)) {
            $plugin->delete();

            $errorMessage = Plugin::isReservedNamespace($namespace)
                ? "The namespace '{$namespace}' is reserved and cannot be used for plugin submissions."
                : "The namespace '{$namespace}' is already claimed by another user. You cannot submit plugins under this namespace.";

            return to_route('customer.plugins.create')
                ->with('error', $errorMessage);
        }

        $user->notify(new PluginSubmitted($plugin));

        $successMessage = 'Your plugin has been submitted for review!';
        if (! $webhookInstalled) {
            $successMessage .= ' Please set up the webhook manually to enable automatic syncing.';
        }

        return to_route('customer.plugins.show', $this->pluginRouteParams($plugin))
            ->with('success', $successMessage);
    }

    public function show(string $vendor, string $package): View
    {
        $plugin = Plugin::findByVendorPackageOrFail($vendor, $package);
        $user = Auth::user();

        if ($plugin->user_id !== $user->id) {
            abort(403);
        }

        return view('customer.plugins.show', compact('plugin'));
    }

    public function update(UpdatePluginDescriptionRequest $request, string $vendor, string $package): RedirectResponse
    {
        $plugin = Plugin::findByVendorPackageOrFail($vendor, $package);
        $user = Auth::user();

        if ($plugin->user_id !== $user->id) {
            abort(403);
        }

        $plugin->updateDescription($request->description, $user->id);

        return to_route('customer.plugins.show', $this->pluginRouteParams($plugin))
            ->with('success', 'Plugin description updated successfully!');
    }

    public function resubmit(string $vendor, string $package): RedirectResponse
    {
        $plugin = Plugin::findByVendorPackageOrFail($vendor, $package);
        $user = Auth::user();

        // Ensure the plugin belongs to the current user
        if ($plugin->user_id !== $user->id) {
            abort(403);
        }

        // Only rejected plugins can be resubmitted
        if (! $plugin->isRejected()) {
            return to_route('customer.plugins.index')
                ->with('error', 'Only rejected plugins can be resubmitted.');
        }

        $plugin->resubmit();

        return to_route('customer.plugins.index')
            ->with('success', 'Your plugin has been resubmitted for review!');
    }

    public function updateLogo(UpdatePluginLogoRequest $request, string $vendor, string $package): RedirectResponse
    {
        $plugin = Plugin::findByVendorPackageOrFail($vendor, $package);
        $user = Auth::user();

        if ($plugin->user_id !== $user->id) {
            abort(403);
        }

        if ($plugin->logo_path) {
            Storage::disk('public')->delete($plugin->logo_path);
        }

        $path = $request->file('logo')->store('plugin-logos', 'public');

        // Clear gradient/icon when uploading a custom logo
        $plugin->update([
            'logo_path' => $path,
            'icon_gradient' => null,
            'icon_name' => null,
        ]);

        return to_route('customer.plugins.show', $this->pluginRouteParams($plugin))
            ->with('success', 'Plugin logo updated successfully!');
    }

    public function updateIcon(Request $request, string $vendor, string $package): RedirectResponse
    {
        $plugin = Plugin::findByVendorPackageOrFail($vendor, $package);
        $user = Auth::user();

        if ($plugin->user_id !== $user->id) {
            abort(403);
        }

        $validated = $request->validate([
            'icon_gradient' => ['required', 'string', 'in:'.implode(',', array_keys(Plugin::gradientPresets()))],
            'icon_name' => ['required', 'string', 'max:100', 'regex:/^[a-z0-9-]+$/'],
        ]);

        // Clear custom logo when using gradient icon
        if ($plugin->logo_path) {
            Storage::disk('public')->delete($plugin->logo_path);
        }

        $plugin->update([
            'logo_path' => null,
            'icon_gradient' => $validated['icon_gradient'],
            'icon_name' => $validated['icon_name'],
        ]);

        return to_route('customer.plugins.show', $this->pluginRouteParams($plugin))
            ->with('success', 'Plugin icon updated successfully!');
    }

    public function deleteLogo(string $vendor, string $package): RedirectResponse
    {
        $plugin = Plugin::findByVendorPackageOrFail($vendor, $package);
        $user = Auth::user();

        if ($plugin->user_id !== $user->id) {
            abort(403);
        }

        if ($plugin->logo_path) {
            Storage::disk('public')->delete($plugin->logo_path);
        }

        $plugin->update([
            'logo_path' => null,
            'icon_gradient' => null,
            'icon_name' => null,
        ]);

        return to_route('customer.plugins.show', $this->pluginRouteParams($plugin))
            ->with('success', 'Plugin icon removed successfully!');
    }

    /**
     * Get route parameters for a plugin's vendor/package URL.
     *
     * @return array{vendor: string, package: string}
     */
    protected function pluginRouteParams(Plugin $plugin): array
    {
        [$vendor, $package] = explode('/', $plugin->name);

        return ['vendor' => $vendor, 'package' => $package];
    }

    public function updateDisplayName(): RedirectResponse
    {
        $user = Auth::user();

        $validated = request()->validate([
            'display_name' => ['nullable', 'string', 'max:255'],
        ]);

        $user->update([
            'display_name' => $validated['display_name'] ?: null,
        ]);

        return to_route('customer.plugins.index')
            ->with('success', 'Display name updated successfully!');
    }
}