<?php

namespace App\Services;

use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Auth;
use Exception;

class BusinessUserService
{
    private string $baseUrl;
    private int $timeout;

    public function __construct()
    {
        $this->baseUrl = config('api.base_url', 'http://localhost:8000/api/v1');
        $this->timeout = config('api.timeout', 30);
    }

    /**
     * Crear un nuevo usuario de negocio en la API externa
     *
     * @param array $accessRequestData
     * @return array
     * @throws Exception
     */
    public function createBusinessUser(array $accessRequestData): array
    {
        try {
            Log::info('BusinessUserService: Iniciando creación de usuario de negocio', [
                'access_request_id' => $accessRequestData['_id'] ?? null,
                'company_name' => $accessRequestData['company_name'] ?? null,
                'requester_email' => $accessRequestData['requester_email'] ?? null
            ]);

            // Preparar los datos para la API
            $apiData = $this->prepareApiData($accessRequestData);

            // Realizar la llamada HTTP usando la configuración centralizada
            $response = Http::timeout($this->timeout)
                ->withHeaders(api_headers())
                ->post(api_url('business.create_user'), $apiData);

            // Verificar si la respuesta fue exitosa
            if ($response->successful()) {
                $responseData = $response->json();
                
                Log::info('BusinessUserService: Usuario de negocio creado exitosamente', [
                    'status' => $response->status(),
                    'response_data' => $responseData
                ]);

                return [
                    'success' => true,
                    'data' => $responseData,
                    'status_code' => $response->status(),
                    'message' => 'Usuario de negocio creado exitosamente'
                ];
            } else {
                Log::error('BusinessUserService: Error en la API externa', [
                    'status' => $response->status(),
                    'response_body' => $response->body(),
                    'headers' => $response->headers()
                ]);

                return [
                    'success' => false,
                    'error' => 'Error en la API externa',
                    'status_code' => $response->status(),
                    'response_body' => $response->body(),
                    'message' => 'No se pudo crear el usuario de negocio'
                ];
            }

        } catch (Exception $e) {
            Log::error('BusinessUserService: Excepción al crear usuario de negocio', [
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString(),
                'access_request_data' => $accessRequestData
            ]);

            return [
                'success' => false,
                'error' => $e->getMessage(),
                'message' => 'Error interno al procesar la solicitud'
            ];
        }
    }

    /**
     * Preparar los datos para enviar a la API externa
     *
     * @param array $accessRequestData
     * @return array
     */
    private function prepareApiData(array $accessRequestData): array
    {
        return [
            'access_request_id' => (string)($accessRequestData['_id'] ?? ''),
            'company_name' => $accessRequestData['company_name'] ?? '',
            'company_tax_id' => $accessRequestData['company_tax_id'] ?? '',
            'company_email' => $accessRequestData['company_email'] ?? '',
            'company_phone' => $accessRequestData['company_phone'] ?? '',
            'company_address' => $accessRequestData['company_address'] ?? '',
            'company_city' => $accessRequestData['company_city'] ?? '',
            'company_country' => $accessRequestData['company_country'] ?? '',
            'requester_name' => $accessRequestData['requester_name'] ?? '',
            'requester_email' => $accessRequestData['requester_email'] ?? '',
            'requester_phone' => $accessRequestData['requester_phone'] ?? '',
            'requester_position' => $accessRequestData['requester_position'] ?? '',
            'business_type' => $accessRequestData['business_type'] ?? '',
            'requested_services' => $accessRequestData['requested_services'] ?? [],
            'comments' => $accessRequestData['comments'] ?? '',
            'created_at' => $accessRequestData['created_at'] ?? now()->toISOString(),
            'approved_at' => now()->toISOString(),
            'approved_by' => Auth::user()->name ?? 'Sistema'
        ];
    }

    /**
     * Verificar el estado de la conexión con la API
     *
     * @return array
     */
    public function checkConnection(): array
    {
        try {
            // Usar el endpoint de health desde la configuración
            $healthEndpoint = config('api.system.health', '/health');
            // Quitar /api/v1 del health check ya que puede no existir
            $baseApiUrl = str_replace('/api/v1', '', $this->baseUrl);
            $response = Http::timeout(10)->get($baseApiUrl . $healthEndpoint);
            
            return [
                'success' => $response->successful(),
                'status_code' => $response->status(),
                'message' => $response->successful() ? 'Conexión exitosa' : 'Error de conexión'
            ];
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage(),
                'message' => 'No se pudo conectar con la API'
            ];
        }
    }

    /**
     * Obtener información de un usuario business
     *
     * @param string $userId
     * @return array
     */
    public function getBusinessUser(string $userId): array
    {
        try {
            $response = Http::timeout($this->timeout)
                ->withHeaders(api_headers())
                ->get(api_url('business.get_user', ['id' => $userId]));

            if ($response->successful()) {
                return [
                    'success' => true,
                    'data' => $response->json(),
                    'message' => 'Usuario obtenido exitosamente'
                ];
            } else {
                return [
                    'success' => false,
                    'error' => 'Error al obtener usuario',
                    'status_code' => $response->status(),
                    'message' => 'No se pudo obtener la información del usuario'
                ];
            }
        } catch (Exception $e) {
            Log::error('Error getting business user', [
                'user_id' => $userId,
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'error' => $e->getMessage(),
                'message' => 'Error interno al obtener usuario'
            ];
        }
    }

    /**
     * Listar usuarios business
     *
     * @param array $filters
     * @return array
     */
    public function listBusinessUsers(array $filters = []): array
    {
        try {
            $response = Http::timeout($this->timeout)
                ->withHeaders(api_headers())
                ->get(api_url('business.list_users'), $filters);

            if ($response->successful()) {
                return [
                    'success' => true,
                    'data' => $response->json(),
                    'message' => 'Usuarios obtenidos exitosamente'
                ];
            } else {
                return [
                    'success' => false,
                    'error' => 'Error al listar usuarios',
                    'status_code' => $response->status(),
                    'message' => 'No se pudieron obtener los usuarios'
                ];
            }
        } catch (Exception $e) {
            Log::error('Error listing business users', [
                'filters' => $filters,
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'error' => $e->getMessage(),
                'message' => 'Error interno al listar usuarios'
            ];
        }
    }

    /**
     * Activar un usuario business
     *
     * @param string $userId
     * @return array
     */
    public function activateBusinessUser(string $userId): array
    {
        try {
            $response = Http::timeout($this->timeout)
                ->withHeaders(api_headers())
                ->post(api_url('business.activate_user', ['id' => $userId]));

            if ($response->successful()) {
                return [
                    'success' => true,
                    'data' => $response->json(),
                    'message' => 'Usuario activado exitosamente'
                ];
            } else {
                return [
                    'success' => false,
                    'error' => 'Error al activar usuario',
                    'status_code' => $response->status(),
                    'message' => 'No se pudo activar el usuario'
                ];
            }
        } catch (Exception $e) {
            Log::error('Error activating business user', [
                'user_id' => $userId,
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'error' => $e->getMessage(),
                'message' => 'Error interno al activar usuario'
            ];
        }
    }

    /**
     * Desactivar un usuario business
     *
     * @param string $userId
     * @return array
     */
    public function deactivateBusinessUser(string $userId): array
    {
        try {
            $response = Http::timeout($this->timeout)
                ->withHeaders(api_headers())
                ->post(api_url('business.deactivate_user', ['id' => $userId]));

            if ($response->successful()) {
                return [
                    'success' => true,
                    'data' => $response->json(),
                    'message' => 'Usuario desactivado exitosamente'
                ];
            } else {
                return [
                    'success' => false,
                    'error' => 'Error al desactivar usuario',
                    'status_code' => $response->status(),
                    'message' => 'No se pudo desactivar el usuario'
                ];
            }
        } catch (Exception $e) {
            Log::error('Error deactivating business user', [
                'user_id' => $userId,
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'error' => $e->getMessage(),
                'message' => 'Error interno al desactivar usuario'
            ];
        }
    }

    /**
     * Obtener lista de solicitudes de acceso
     *
     * @param array $params
     * @return array
     */
    public function getAccessRequests(array $params = []): array
    {
        try {
            $response = Http::timeout($this->timeout)
                ->withHeaders(api_headers())
                ->get(api_url('access_requests.list'), $params);

            if ($response->successful()) {
                return [
                    'success' => true,
                    'data' => $response->json(),
                    'message' => 'Solicitudes obtenidas exitosamente'
                ];
            } else {
                return [
                    'success' => false,
                    'error' => 'Error al obtener solicitudes',
                    'status_code' => $response->status(),
                    'message' => 'No se pudieron obtener las solicitudes de acceso'
                ];
            }
        } catch (Exception $e) {
            Log::error('Error getting access requests', [
                'params' => $params,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return [
                'success' => false,
                'error' => $e->getMessage(),
                'message' => 'Error interno al obtener solicitudes'
            ];
        }
    }

    /**
     * Obtener una solicitud de acceso específica
     *
     * @param string $id
     * @return array
     */
    public function getAccessRequest(string $id): array
    {
        try {
            $response = Http::timeout($this->timeout)
                ->withHeaders(api_headers())
                ->get(api_url('access_requests.show', ['id' => $id]));

            if ($response->successful()) {
                return [
                    'success' => true,
                    'data' => $response->json(),
                    'message' => 'Solicitud obtenida exitosamente'
                ];
            } else {
                return [
                    'success' => false,
                    'error' => 'Error al obtener solicitud',
                    'status_code' => $response->status(),
                    'message' => 'No se pudo obtener la solicitud de acceso'
                ];
            }
        } catch (Exception $e) {
            Log::error('Error getting access request', [
                'id' => $id,
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'error' => $e->getMessage(),
                'message' => 'Error interno al obtener solicitud'
            ];
        }
    }

    /**
     * Aprobar una solicitud de acceso
     *
     * @param string $id
     * @return array
     */
    public function approveAccessRequest(string $id): array
    {
        try {
            $response = Http::timeout($this->timeout)
                ->withHeaders(api_headers())
                ->post(api_url('access_requests.approve', ['id' => $id]));

            if ($response->successful()) {
                return [
                    'success' => true,
                    'data' => $response->json(),
                    'message' => 'Solicitud aprobada exitosamente'
                ];
            } else {
                return [
                    'success' => false,
                    'error' => 'Error al aprobar solicitud',
                    'status_code' => $response->status(),
                    'message' => 'No se pudo aprobar la solicitud'
                ];
            }
        } catch (Exception $e) {
            Log::error('Error approving access request', [
                'id' => $id,
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'error' => $e->getMessage(),
                'message' => 'Error interno al aprobar solicitud'
            ];
        }
    }

    /**
     * Rechazar una solicitud de acceso
     *
     * @param string $id
     * @return array
     */
    public function rejectAccessRequest(string $id): array
    {
        try {
            $response = Http::timeout($this->timeout)
                ->withHeaders(api_headers())
                ->post(api_url('access_requests.reject', ['id' => $id]));

            if ($response->successful()) {
                return [
                    'success' => true,
                    'data' => $response->json(),
                    'message' => 'Solicitud rechazada exitosamente'
                ];
            } else {
                return [
                    'success' => false,
                    'error' => 'Error al rechazar solicitud',
                    'status_code' => $response->status(),
                    'message' => 'No se pudo rechazar la solicitud'
                ];
            }
        } catch (Exception $e) {
            Log::error('Error rejecting access request', [
                'id' => $id,
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'error' => $e->getMessage(),
                'message' => 'Error interno al rechazar solicitud'
            ];
        }
    }

    /**
     * Obtener estadísticas de solicitudes de acceso
     *
     * @return array
     */
    public function getAccessRequestStats(): array
    {
        try {
            $response = Http::timeout($this->timeout)
                ->withHeaders(api_headers())
                ->get(api_url('access_requests.stats'));

            if ($response->successful()) {
                return [
                    'success' => true,
                    'data' => $response->json(),
                    'message' => 'Estadísticas obtenidas exitosamente'
                ];
            } else {
                return [
                    'success' => false,
                    'error' => 'Error al obtener estadísticas',
                    'status_code' => $response->status(),
                    'message' => 'No se pudieron obtener las estadísticas'
                ];
            }
        } catch (Exception $e) {
            Log::error('Error getting access request stats', [
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'error' => $e->getMessage(),
                'message' => 'Error interno al obtener estadísticas'
            ];
        }
    }
}