<?php

namespace App\Jobs\PBX;

use App\Exceptions\PBX\ExtensionException;
use App\Services\PBX\ExtensionManager;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Str;
use Modules\Platform\User\Entities\User;
use Modules\Platform\User\Entities\UserExtension;
use Modules\Platform\User\Service\UserService;

/**
 * Create FreePBX Extension Job
 *
 * Async job to create an extension in FreePBX via REST API
 */
class CreateExtensionJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    /**
     * The number of times the job may be attempted.
     *
     * @var int
     */
    public $tries = 3;

    /**
     * The number of seconds to wait before retrying the job.
     *
     * @var int
     */
    public $backoff = 30;

    /**
     * Extension data
     *
     * @var array
     */
    protected $extensionData;

    /**
     * User Extension ID (optional, for updating sync status)
     *
     * @var int|null
     */
    protected $userExtensionId;

    /**
     * Create a new job instance.
     *
     * @param array $extensionData
     * @param int|null $userExtensionId
     */
    public function __construct(array $extensionData, ?int $userExtensionId = null)
    {
        $this->extensionData = $extensionData;
        $this->userExtensionId = $userExtensionId;
    }

    /**
     * Execute the job.
     *
     * @param UserService $userService
     * @param ExtensionManager $extensionManager
     * @return void
     */
    public function handle(UserService $userService, ExtensionManager $extensionManager)
    {
        $extension = $this->extensionData['extension'] ?? 'unknown';
        $secret    = $this->extensionData['secret'] ?? Str::random(14);

        try {
            // Update sync status to 'syncing'
            $this->updateSyncStatus('syncing');

            Log::info('Job: Creating PBX extension', [
                'extension' => $extension,
                'user_extension_id' => $this->userExtensionId,
            ]);

            $user = User::find($extension);

            if (!$user) {
                throw new \Exception("User not found for extension {$extension}");
            }

            $userService->addAsteriskUser($user, $secret);

            $extensionManager->applyChanges();

            // Update sync status to 'synced'
            $this->updateSyncStatus('synced', null);

            Log::info('Job: PBX extension created successfully', [
                'extension' => $extension,
            ]);

        } catch (ExtensionException $e) {
            $this->handleFailure($e, $extension);
        } catch (\Exception $e) {
            $this->handleFailure($e, $extension);
        }
    }

    /**
     * Handle a job failure.
     *
     * @param \Exception $exception
     * @param string $extension
     * @return void
     */
    protected function handleFailure(\Exception $exception, string $extension)
    {
        Log::error('Job: Failed to create PBX extension', [
            'extension' => $extension,
            'user_extension_id' => $this->userExtensionId,
            'error' => $exception->getMessage(),
            'attempts' => $this->attempts(),
        ]);

        // Update sync status
        $this->updateSyncStatus('failed', $exception->getMessage());

        // If max attempts reached, mark as permanently failed
        if ($this->attempts() >= $this->tries) {
            Log::error('Job: Max attempts reached for creating PBX extension', [
                'extension' => $extension,
                'user_extension_id' => $this->userExtensionId,
            ]);
        }

        // Re-throw to mark job as failed
        throw $exception;
    }

    /**
     * Update sync status in user_extensions table
     *
     * @param string $status
     * @param string|null $error
     * @return void
     */
    protected function updateSyncStatus(string $status, ?string $error = null)
    {
        if (!$this->userExtensionId) {
            return;
        }

        try {
            $userExtension = UserExtension::find($this->userExtensionId);

            if ($userExtension) {
                $data = [
                    'pbx_sync_status' => $status,
                    'pbx_sync_attempts' => $userExtension->pbx_sync_attempts + 1,
                ];

                if ($status === 'synced') {
                    $data['pbx_last_synced_at'] = now();
                    $data['pbx_sync_error'] = null;
                } elseif ($status === 'failed' && $error) {
                    $data['pbx_sync_error'] = $error;
                }

                $userExtension->update($data);
            }
        } catch (\Exception $e) {
            Log::warning('Failed to update sync status', [
                'user_extension_id' => $this->userExtensionId,
                'error' => $e->getMessage(),
            ]);
        }
    }
}