<?php

namespace App\Http\Controllers;

use App\Jobs\GenerateImageJob;
use App\Models\Conversation;
use App\Services\ImageConfigService;
use App\Services\SynchronousImageGenerationService;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Log;
use Ramsey\Uuid\Uuid;

class ImageGenerationController extends Controller
{
	/**
	 * Generate a single image (new individual endpoint)
	 */
	public function generateSingle(Request $request)
	{
		$request->validate([
			'id' => 'required|string',
			'alt' => 'required|string',
			'src' => 'required|string',
			'conversation_id' => 'required|integer|exists:conversations,id'
		]);
		
		$imageId = $request->input('id');
		$prompt = $request->input('alt');
		$conversationId = $request->input('conversation_id');
		$userId = auth()->id();
		
		Log::info("Individual image generation request", [
			'image_id' => $imageId,
			'conversation_id' => $conversationId,
			'user_id' => $userId,
			'prompt' => substr($prompt, 0, 100) . '...'
		]);
		
		// Clean the prompt
		$cleanPrompt = $this->cleanImagePrompt($prompt);
		if (empty($cleanPrompt)) {
			return response()->json([
				'success' => false,
				'error' => 'Invalid or empty prompt'
			], 400);
		}
		
		// Dispatch job and get job ID
		$job = new GenerateImageJob($imageId, $cleanPrompt, $conversationId, $userId);
		$jobId = uniqid('img_job_', true);
		
		// Store job mapping
		cache()->put("job_mapping_{$jobId}", [
			'image_id' => $imageId,
			'conversation_id' => $conversationId,
			'user_id' => $userId,
			'status' => 'queued',
			'created_at' => now()->toISOString()
		], 600); // 10 minutes
		
		// Dispatch with job ID
		dispatch($job->onQueue('images')->delay(0))->onConnection('redis');
		
		return response()->json([
			'success' => true,
			'job_id' => $jobId,
			'image_id' => $imageId,
			'status' => 'queued'
		]);
	}
	
	/**
	 * Check job status (new endpoint)
	 */
	public function checkJobStatus(Request $request)
	{
		$request->validate([
			'job_id' => 'required|string'
		]);
		
		$jobId = $request->input('job_id');
		$jobData = cache()->get("job_mapping_{$jobId}");
		
		if (!$jobData) {
			return response()->json([
				'success' => false,
				'error' => 'Job not found or expired'
			], 404);
		}
		
		// Check if image was generated successfully
		$conversation = Conversation::find($jobData['conversation_id']);
		if (!$conversation) {
			return response()->json([
				'success' => false,
				'error' => 'Conversation not found'
			], 404);
		}
		
		$generatedImages = $conversation->ai_responses['generated_images'] ?? [];
		$imageResult = $generatedImages[$jobData['image_id']] ?? null;
		
		if ($imageResult) {
			// Check if file actually exists
			$fullPath = storage_path('app/public/' . $imageResult['path']);
			if (file_exists($fullPath) && filesize($fullPath) > 1024) {
				// Success - image generated and file exists
				return response()->json([
					'success' => true,
					'status' => 'completed',
					'job_id' => $jobId,
					'image_id' => $jobData['image_id'],
					'image_path' => $imageResult['path'],
					'image_url' => $imageResult['url'],
					'generated_at' => $imageResult['generated_at'] ?? null
				]);
			}
		}
		
		// Check if job failed
		$failedImages = $conversation->ai_responses['failed_images'] ?? [];
		if (isset($failedImages[$jobData['image_id']])) {
			return response()->json([
				'success' => false,
				'status' => 'failed',
				'job_id' => $jobId,
				'image_id' => $jobData['image_id'],
				'error' => $failedImages[$jobData['image_id']]['error'] ?? 'Unknown error',
				'retryable' => true
			]);
		}
		
		// Still processing
		return response()->json([
			'success' => true,
			'status' => 'processing',
			'job_id' => $jobId,
			'image_id' => $jobData['image_id']
		]);
	}
	
	/**
	 * Legacy batch endpoint (keeping for compatibility)
	 */
	public function batchGenerate(Request $request)
	{
		$request->validate([
			'images' => 'required|array',
			'images.*.id' => 'required|string',
			'images.*.alt' => 'required|string',
			'images.*.src' => 'required|string',
			'conversation_id' => 'required|integer|exists:conversations,id'
		]);
		
		$images = $request->input('images');
		$conversationId = $request->input('conversation_id');
		$userId = auth()->id();
		
		Log::info("Batch image generation request", [
			'conversation_id' => $conversationId,
			'user_id' => $userId,
			'image_count' => count($images)
		]);
		
		// Process using synchronous service (legacy)
		try {
			$synchronousService = app(SynchronousImageGenerationService::class);
			$results = $synchronousService->processImagesSequentially($images, $conversationId, $userId);
			
			return response()->json([
				'success' => true,
				'results' => $results
			]);
			
		} catch (Exception $e) {
			Log::error("Batch image generation failed", [
				'error' => $e->getMessage(),
				'conversation_id' => $conversationId
			]);
			
			return response()->json([
				'success' => false,
				'error' => $e->getMessage()
			], 500);
		}
	}
	
	/**
	 * Check status endpoint (legacy - keeping for compatibility)
	 */
	public function checkStatus(Request $request)
	{
		$request->validate([
			'conversation_id' => 'required|integer|exists:conversations,id'
		]);
		
		$conversationId = $request->input('conversation_id');
		$conversation = Conversation::find($conversationId);
		
		if (!$conversation) {
			return response()->json([
				'success' => false,
				'error' => 'Conversation not found'
			], 404);
		}
		
		$generatedImages = $conversation->ai_responses['generated_images'] ?? [];
		$failedImages = $conversation->ai_responses['failed_images'] ?? [];
		
		$statusData = [
			'conversation_id' => $conversationId,
			'generated_images' => $generatedImages,
			'failed_images' => $failedImages,
			'total_generated' => count($generatedImages),
			'total_failed' => count($failedImages)
		];
		
		return response()->json([
			'success' => true,
			'data' => $statusData
		]);
	}
	
	/**
	 * Get generated images (legacy)
	 */
	public function getGeneratedImages(Request $request)
	{
		$request->validate([
			'conversation_id' => 'required|integer|exists:conversations,id'
		]);
		
		$conversationId = $request->input('conversation_id');
		$conversation = Conversation::find($conversationId);
		
		if (!$conversation) {
			return response()->json([
				'success' => false,
				'error' => 'Conversation not found'
			], 404);
		}
		
		$generatedImages = $conversation->ai_responses['generated_images'] ?? [];
		
		return response()->json([
			'success' => true,
			'images' => $generatedImages,
			'total' => count($generatedImages)
		]);
	}
	
	/**
	 * Clean image prompt
	 */
	private function cleanImagePrompt(string $prompt): string
	{
		// Remove HTML tags
		$cleaned = strip_tags($prompt);
		
		// Remove extra whitespace
		$cleaned = preg_replace('/\s+/', ' ', $cleaned);
		
		// Trim and validate
		$cleaned = trim($cleaned);
		
		if (strlen($cleaned) < 3) {
			return '';
		}
		
		if (strlen($cleaned) > 400) {
			$cleaned = substr($cleaned, 0, 400);
		}
		
		return $cleaned;
	}
}