<?php

namespace App\Controllers;

use App\Controllers\BaseController;
use App\Models\UserModel;  //model que voy a usar, para usuarios
use CodeIgniter\HTTP\Response;
use CodeIgniter\API\ResponseTrait;
use CodeIgniter\HTTP\ResponseInterface;


$allowedOrigins = [
    // 'https://catchef.bravecatstudios.com',  // Producción
    'http://localhost:4200', // Desarrollo en local
    'http://localhost:8000',
];

if (isset($_SERVER['HTTP_ORIGIN']) && in_array($_SERVER['HTTP_ORIGIN'], $allowedOrigins)) {
    header('Access-Control-Allow-Origin: ' . $_SERVER['HTTP_ORIGIN']);
}

header('Access-Control-Allow-Methods: GET, POST, OPTIONS, PUT, DELETE');
header('Access-Control-Allow-Headers: Content-Type, Authorization');
header('Access-Control-Allow-Credentials: true');

class UserController extends BaseController
{
    protected $userModel;

    public function __construct(){
        $this->userModel = new UserModel();
    }
    

    public function getUserById($userId)
    {
        // Obtiene el usuario por ID
        $user = $this->userModel->find($userId);

        if (!$user) {
            return $this->response->setJSON([
                'status' => 'error',
                'message' => 'Usuario no encontrado'
            ])->setStatusCode(Response::HTTP_NOT_FOUND);
        }

        // Asegura que PhotoUrl sea absoluto
        if (!empty($user['PhotoUrl'])) {
            // base_url() usa la URL configurada en app/Config/App.php
            $user['PhotoUrl'] = base_url($user['PhotoUrl']);
        } else {
            // Imagen por defecto
            $user['PhotoUrl'] = base_url('uploads/users/default-avatar.png');
        }

        return $this->response->setJSON([
            'status' => 'success',
            'user' => $user
        ]);
    }

    

    public function uploadPhoto()
    {
        $userId = $this->request->getPost('userId');
        $file   = $this->request->getFile('photo');

        if (!$userId || !$file || !$file->isValid()) {
            return $this->response->setJSON([
                'status'  => 'error',
                'message' => 'Datos inválidos'
            ])->setStatusCode(ResponseInterface::HTTP_BAD_REQUEST);
        }

        // (Opcional) valida tipo/extensión
        $ext = strtolower($file->getExtension() ?: $file->guessExtension());
        $allowed = ['jpg','jpeg','png','webp'];
        if (!in_array($ext, $allowed)) {
            return $this->response->setJSON([
                'status'  => 'error',
                'message' => 'Formato no permitido. Usa JPG, PNG o WEBP.'
            ])->setStatusCode(ResponseInterface::HTTP_BAD_REQUEST);
        }

        // Ruta destino: /public/uploads/users/{userId}/
        $uploadPath = rtrim(FCPATH, '/\\') . '/uploads/users/' . $userId . '/';

        // Crea carpeta si no existe
        if (!is_dir($uploadPath)) {
            mkdir($uploadPath, 0777, true);
        } else {
            // Limpia TODO el contenido previo (archivos y subcarpetas)
            $this->clearDirectory($uploadPath);
        }

        // Nombre nuevo (predecible para cache-busting o único)
        $newName = 'avatar_' . time() . '.' . $ext;

        // Mueve el archivo
        if (!$file->move($uploadPath, $newName)) {
            return $this->response->setJSON([
                'status'  => 'error',
                'message' => 'No se pudo mover el archivo'
            ])->setStatusCode(ResponseInterface::HTTP_INTERNAL_SERVER_ERROR);
        }

        // Guarda ruta relativa en BD y devuelve absoluta en la respuesta
        $relativePath = 'uploads/users/' . $userId . '/' . $newName;
        $absoluteUrl  = base_url($relativePath);

        $this->userModel->update($userId, ['PhotoUrl' => $relativePath]);

        return $this->response->setJSON([
            'status'   => 'success',
            'message'  => 'Foto actualizada correctamente',
            'photoUrl' => $absoluteUrl
        ])->setStatusCode(ResponseInterface::HTTP_OK);
    }

    public function updateProfile()
    {
        // Obtenemos los datos enviados por POST
        $data = $this->request->getJSON(true);

        // Validamos que se haya enviado el ID del usuario
        if (empty($data['PK_User'])) {
            return $this->response->setJSON([
                'status' => 'error',
                'message' => 'ID de usuario requerido'
            ])->setStatusCode(400);
        }

        // Validamos datos básicos
        if (empty($data['Name']) || empty($data['Email'])) {
            return $this->response->setJSON([
                'status' => 'error',
                'message' => 'Nombre y correo son obligatorios'
            ])->setStatusCode(400);
        }

        // Preparamos los datos para actualizar
        $updateData = [
            'Name'        => $data['Name'],
            'Email'       => $data['Email'],
            'PhoneNumber' => $data['PhoneNumber'] ?? null
        ];

        // Ejecutamos la actualización
        $updated = $this->userModel->update($data['PK_User'], $updateData);

        if (!$updated) {
            return $this->response->setJSON([
                'status'  => 'error',
                'message' => 'No se pudo actualizar el perfil'
            ])->setStatusCode(500);
        }

        // Obtenemos la información actualizada
        $user = $this->userModel->find($data['PK_User']);

        // Ajustamos la URL de la foto para que sea absoluta
        if (!empty($user['PhotoUrl'])) {
            $user['PhotoUrl'] = base_url($user['PhotoUrl']);
        } else {
            $user['PhotoUrl'] = base_url('uploads/users/default-avatar.png');
        }

        return $this->response->setJSON([
            'status'  => 'success',
            'message' => 'Perfil actualizado correctamente',
            'user'    => $user
        ]);
    }

    public function changePassword()
    {
        // Acepta JSON o form-data
        $json = $this->request->getJSON(true) ?? [];
        $post = !empty($json) ? $json : $this->request->getPost();

        $userId          = $post['userId'] ?? null;
        $currentPassword = $post['currentPassword'] ?? null;
        $newPassword     = $post['newPassword'] ?? null;

        if (empty($userId) || empty($currentPassword) || empty($newPassword)) {
            return $this->response->setJSON([
                'status'  => 'error',
                'message' => 'Parámetros incompletos',
            ])->setStatusCode(ResponseInterface::HTTP_BAD_REQUEST);
        }

        if (mb_strlen($newPassword) < 6) {
            return $this->response->setJSON([
                'status'  => 'error',
                'message' => 'La nueva contraseña debe tener al menos 6 caracteres.',
            ])->setStatusCode(ResponseInterface::HTTP_BAD_REQUEST);
        }

        $user = $this->userModel->find($userId);
        if (!$user) {
            return $this->response->setJSON([
                'status'  => 'error',
                'message' => 'Usuario no encontrado',
            ])->setStatusCode(ResponseInterface::HTTP_NOT_FOUND);
        }

        $hash = $user['Password'] ?? '';
        if (!password_verify($currentPassword, $hash)) {
            return $this->response->setJSON([
                'status'  => 'error',
                'message' => 'La contraseña actual es incorrecta',
            ])->setStatusCode(ResponseInterface::HTTP_UNAUTHORIZED);
        }

        if (password_verify($newPassword, $hash)) {
            return $this->response->setJSON([
                'status'  => 'error',
                'message' => 'La nueva contraseña no puede ser igual a la actual',
            ])->setStatusCode(ResponseInterface::HTTP_BAD_REQUEST);
        }

        $newHash = password_hash($newPassword, PASSWORD_DEFAULT);

        if (!$this->userModel->update($userId, ['Password' => $newHash])) {
            // Si usas reglas en el modelo, puedes inspeccionar $this->userModel->errors()
            return $this->response->setJSON([
                'status'  => 'error',
                'message' => 'No se pudo actualizar la contraseña',
            ])->setStatusCode(ResponseInterface::HTTP_INTERNAL_SERVER_ERROR);
        }

        return $this->response->setJSON([
            'status'  => 'success',
            'message' => 'Contraseña actualizada correctamente',
        ])->setStatusCode(ResponseInterface::HTTP_OK);
    }

    private function clearDirectory(string $dir): void
    {
        $dir = rtrim($dir, '/\\') . DIRECTORY_SEPARATOR;

        if (!is_dir($dir)) {
            return;
        }

        foreach (scandir($dir) as $item) {
            if ($item === '.' || $item === '..') {
                continue;
            }
            $path = $dir . $item;

            if (is_file($path) || is_link($path)) {
                @unlink($path);
            } elseif (is_dir($path)) {
                $this->rrmdir($path); // elimina subcarpeta completa
            }
        }
    }

    /** Elimina un directorio de forma recursiva (incluyendo su contenido) */
    private function rrmdir(string $dir): void
    {
        if (!is_dir($dir)) {
            return;
        }
        $items = new \RecursiveIteratorIterator(
            new \RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS),
            \RecursiveIteratorIterator::CHILD_FIRST
        );
        foreach ($items as $item) {
            $item->isDir() ? @rmdir($item->getPathname()) : @unlink($item->getPathname());
        }
        @rmdir($dir);
    }
}



