<?php

namespace App\Controllers;

use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use App\Response\ApiResponse;
use App\Container\ServiceContainer;

abstract class BaseController
{
    /**
     * Get service from container
     */
    protected function getService(string $serviceClass)
    {
        return ServiceContainer::get($serviceClass);
    }

    /**
     * Create JSON response
     */
    protected function jsonResponse(Response $response, array $data, int $status = 200): Response
    {
        return ApiResponse::json($response, $data, $status);
    }

    /**
     * Create success response
     */
    protected function successResponse(Response $response, $data = null, string $message = 'Success', int $status = 200): Response
    {
        $responseData = $data ?? [];
        $body = json_encode(ApiResponse::success($responseData, $status));
        $response->getBody()->write($body);
        return $response
            ->withHeader('Content-Type', 'application/json')
            ->withStatus($status);
    }

    /**
     * Create error response
     */
    protected function errorResponse(Response $response, string $message = 'Error', int $status = 400, array $errors = []): Response
    {
        $body = json_encode(ApiResponse::error($message, $status));
        $response->getBody()->write($body);
        return $response
            ->withHeader('Content-Type', 'application/json')
            ->withStatus($status);
    }

    /**
     * Create validation error response
     */
    protected function validationErrorResponse(Response $response, array $errors, string $message = 'Validation failed'): Response
    {
        $body = json_encode([
            'status' => 422,
            'success' => false,
            'error' => $message,
            'errors' => $errors
        ]);
        $response->getBody()->write($body);
        return $response
            ->withHeader('Content-Type', 'application/json')
            ->withStatus(422);
    }

    /**
     * Create not found response
     */
    protected function notFoundResponse(Response $response, string $message = 'Resource not found'): Response
    {
        $body = json_encode(ApiResponse::error($message, 404));
        $response->getBody()->write($body);
        return $response
            ->withHeader('Content-Type', 'application/json')
            ->withStatus(404);
    }

    /**
     * Create unauthorized response
     */
    protected function unauthorizedResponse(Response $response, string $message = 'Unauthorized'): Response
    {
        $body = json_encode(ApiResponse::error($message, 401));
        $response->getBody()->write($body);
        return $response
            ->withHeader('Content-Type', 'application/json')
            ->withStatus(401);
    }

    /**
     * Create forbidden response
     */
    protected function forbiddenResponse(Response $response, string $message = 'Forbidden'): Response
    {
        $body = json_encode(ApiResponse::error($message, 403));
        $response->getBody()->write($body);
        return $response
            ->withHeader('Content-Type', 'application/json')
            ->withStatus(403);
    }

    /**
     * Get pagination parameters from request
     */
    protected function getPaginationParams(Request $request): array
    {
        $params = $request->getQueryParams();
        
        return [
            'page' => max(1, (int) ($params['page'] ?? 1)),
            'limit' => min(100, max(1, (int) ($params['limit'] ?? 20)))
        ];
    }

    /**
     * Get filter parameters from request
     */
    protected function getFilterParams(Request $request, array $allowedFilters = []): array
    {
        $params = $request->getQueryParams();
        $filters = [];

        foreach ($allowedFilters as $filter) {
            if (isset($params[$filter])) {
                $filters[$filter] = $params[$filter];
            }
        }

        return $filters;
    }

    /**
     * Get search term from request
     */
    protected function getSearchTerm(Request $request): ?string
    {
        $params = $request->getQueryParams();
        return isset($params['search']) && !empty($params['search']) ? $params['search'] : null;
    }

    /**
     * Get user email from request attributes (set by middleware)
     */
    protected function getUserEmail(Request $request): ?string
    {
        return $request->getAttribute('user_email');
    }

    /**
     * Get user ID from request attributes (set by middleware)
     * @deprecated Use getUserEmail() instead for security
     */
    protected function getUserId(Request $request): ?int
    {
        // For backward compatibility, get user by email
        $email = $this->getUserEmail($request);
        if (!$email) {
            return null;
        }
        
        $user = \App\Models\User::where('email', $email)->first();
        return $user ? $user->id : null;
    }

    /**
     * Get user from request attributes (set by middleware)
     */
    protected function getUser(Request $request)
    {
        $user = $request->getAttribute('user');
        if ($user) {
            return $user;
        }
        
        // Fallback: get user by email from token
        $email = $this->getUserEmail($request);
        if ($email) {
            return \App\Models\User::where('email', $email)->first();
        }
        
        return null;
    }

    /**
     * Check if user has permission for a module
     */
    protected function hasPermission(Request $request, string $moduleName): bool
    {
        $user = $this->getUser($request);
        if (!$user) {
            return false;
        }

        // If user object has hasModulePermission method (Eloquent model)
        if (method_exists($user, 'hasModulePermission')) {
            return $user->hasModulePermission($moduleName);
        }

        // Fallback for legacy user objects
        return false;
    }

    /**
     * Handle exceptions and return appropriate response
     */
    protected function handleException(Response $response, \Exception $e): Response
    {
        if ($e instanceof \App\Exceptions\ValidationException) {
            return $this->validationErrorResponse($response, $e->getErrors(), $e->getMessage());
        }

        if ($e instanceof \App\Exceptions\UnauthorizedException) {
            return $this->unauthorizedResponse($response, $e->getMessage());
        }

        if ($e instanceof \App\Exceptions\ApiException) {
            return $this->errorResponse($response, $e->getMessage(), $e->getStatusCode());
        }

        // Log unexpected errors
        error_log('Unexpected error: ' . $e->getMessage() . ' in ' . $e->getFile() . ':' . $e->getLine());

        return $this->errorResponse($response, 'Internal server error', 500);
    }

    /**
     * Transform paginated results for API response
     */
    protected function transformPaginatedResults($paginatedResults): array
    {
        return [
            'data' => $paginatedResults->items(),
            'pagination' => [
                'current_page' => $paginatedResults->currentPage(),
                'last_page' => $paginatedResults->lastPage(),
                'per_page' => $paginatedResults->perPage(),
                'total' => $paginatedResults->total(),
                'from' => $paginatedResults->firstItem(),
                'to' => $paginatedResults->lastItem(),
                'has_more_pages' => $paginatedResults->hasMorePages()
            ]
        ];
    }

    /**
     * Validate required fields in request data
     */
    protected function validateRequiredFields(array $data, array $requiredFields): array
    {
        $errors = [];
        
        foreach ($requiredFields as $field) {
            if (!isset($data[$field]) || empty($data[$field])) {
                $errors[$field] = "The {$field} field is required.";
            }
        }

        return $errors;
    }

    /**
     * Sanitize input data
     */
    protected function sanitizeInput(array $data, array $allowedFields = []): array
    {
        if (empty($allowedFields)) {
            return $data;
        }

        return array_intersect_key($data, array_flip($allowedFields));
    }
}