#!/bin/bash

#-------------------------------------COLORES PARA MENSAJES------------------------------------------------------------
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
MAGENTA='\033[0;35m'
NC='\033[0m' # No Color
BOLD='\033[1m'

#-------------------------------------FUNCIONES DE MENSAJES------------------------------------------------------------
print_header() {
    echo ""
    echo -e "${CYAN}╔═══════════════════════════════════════════════════════════════╗${NC}"
    echo -e "${CYAN}║                                                               ║${NC}"
    echo -e "${CYAN}║  ${BOLD}${MAGENTA}     APIDIAN - Instalación Docker (Sin Dominio)${NC}${CYAN}            ║${NC}"
    echo -e "${CYAN}║  ${BLUE}     Laravel 8 + MariaDB + Nginx + OpenSSL Legacy${NC}${CYAN}            ║${NC}"
    echo -e "${CYAN}║                                                               ║${NC}"
    echo -e "${CYAN}╚═══════════════════════════════════════════════════════════════╝${NC}"
    echo ""
}

print_success() {
    echo -e "${GREEN}✓ $1${NC}"
}

print_error() {
    echo -e "${RED}✗ $1${NC}"
}

print_warning() {
    echo -e "${YELLOW}⚠ $1${NC}"
}

print_info() {
    echo -e "${BLUE}ℹ $1${NC}"
}

print_step() {
    echo ""
    echo -e "${CYAN}${BOLD}▶ $1${NC}"
    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
}

# Función para ejecutar comandos con spinner y timeout
run_with_spinner() {
    local cmd="$1"
    local msg="$2"
    local timeout="${3:-300}" # timeout por defecto 5 minutos

    print_info "$msg"

    # Ejecutar comando en background
    eval "$cmd" > /tmp/install_output.log 2>&1 &
    local pid=$!

    # Spinner
    local spin='-\|/'
    local i=0
    local elapsed=0

    while kill -0 $pid 2>/dev/null; do
        i=$(( (i+1) %4 ))
        printf "\r${CYAN}   Procesando... ${spin:$i:1} (${elapsed}s)${NC}"
        sleep 1
        elapsed=$((elapsed + 1))

        if [ $elapsed -ge $timeout ]; then
            kill -9 $pid 2>/dev/null
            printf "\r"
            print_error "Tiempo de espera agotado después de ${timeout}s"
            print_info "Revisa los logs en /tmp/install_output.log"
            cat /tmp/install_output.log
            return 1
        fi
    done

    wait $pid
    local exit_code=$?
    printf "\r"

    if [ $exit_code -eq 0 ]; then
        return 0
    else
        print_error "Comando falló con código $exit_code"
        print_info "Últimas líneas del log:"
        tail -20 /tmp/install_output.log
        return $exit_code
    fi
}

# Habilitar modo debug si se pasa como argumento
if [[ "$*" == *"--debug"* ]]; then
    set -x
    print_warning "Modo DEBUG activado"
fi

# Mostrar header
print_header

#-------------------------------------VERIFICAR ROOT------------------------------------------------------------
if [ "$EUID" -ne 0 ]; then
    print_error "Este script debe ejecutarse como root"
    echo -e "${YELLOW}Usa: sudo bash $0${NC}"
    exit 1
fi

print_success "Ejecutando como root"

# Información del sistema
UBUNTU_VERSION=$(lsb_release -rs)
print_info "Sistema: Ubuntu $UBUNTU_VERSION"
print_info "Conectividad: $(ping -c 1 8.8.8.8 > /dev/null 2>&1 && echo 'OK' || echo 'SIN INTERNET')"

# Verificar versión de Ubuntu soportada (Docker funciona con cualquier versión, pero mínimo 20.04 recomendado)
UBUNTU_MAJOR=$(echo "$UBUNTU_VERSION" | cut -d. -f1)

if [[ "$UBUNTU_MAJOR" -lt 20 ]]; then
    print_error "APIDIAN 2026 con Docker no es compatible con Ubuntu versiones menores a 20.04"
    print_warning "Tu versión: Ubuntu $UBUNTU_VERSION"
    print_info "Se requiere mínimo Ubuntu 20.04 LTS con Docker"
    exit 1
elif [[ ! "$UBUNTU_VERSION" =~ ^(20.04|22.04|24.04) ]]; then
    print_warning "Ubuntu $UBUNTU_VERSION no ha sido testeada oficialmente"
    print_info "Se procederá con instalación (compatibilidad parcial)"
fi

print_success "Versión de Ubuntu compatible con Docker"

# Mostrar tiempos estimados
echo ""
echo -e "${BLUE}⏱️  Tiempo estimado total: ${BOLD}15-25 minutos${NC}"
echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${CYAN}   • Instalación de Docker: ~3-5 min${NC}"
echo -e "${CYAN}   • Clonación del repositorio: ~1-3 min${NC}"
echo -e "${CYAN}   • Construcción de imagen PHP 8: ~5-10 min${NC}"
echo -e "${CYAN}   • Instalación de dependencias: ~3-5 min${NC}"
echo -e "${CYAN}   • Configuración de la aplicación: ~2-3 min${NC}"
echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""

#-------------------------------------DETECTAR IP DEL SERVIDOR---------------------------------------------------------
print_step "Detectando dirección IP del servidor"

# Intentar obtener la IP pública IPv4
SERVER_IP=$(curl -4 -s ifconfig.me 2>/dev/null || curl -4 -s icanhazip.com 2>/dev/null || curl -4 -s ipinfo.io/ip 2>/dev/null)

if [ -z "$SERVER_IP" ]; then
    # Si no se puede obtener IP pública, usar IP local IPv4
    SERVER_IP=$(hostname -I | grep -oE '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' | head -n1)
    if [ -z "$SERVER_IP" ]; then
        SERVER_IP=$(ip -4 addr show | grep -oP '(?<=inet\s)\d+(\.\d+){3}' | grep -v '127.0.0.1' | head -n1)
    fi
    print_warning "No se pudo detectar IP pública, usando IP local: $SERVER_IP"
else
    print_success "IP pública detectada: ${BOLD}$SERVER_IP${NC}"
fi

# Permitir al usuario confirmar o cambiar la IP
echo ""
read -p "$(echo -e ${YELLOW}¿Es correcta esta IP? [s/n]: ${NC})" confirm_ip
if [ "$confirm_ip" != "s" ]; then
    read -p "$(echo -e ${CYAN}Ingresa la IP correcta: ${NC})" SERVER_IP
    print_success "IP configurada manualmente: $SERVER_IP"
fi

#-------------------------------------CONFIGURACION DE MYSQL-----------------------------------------------------------
DEFAULT_PORT='3306'
echo ""
echo -e "${BLUE}Configuración de MySQL:${NC}"
read -p "$(echo -e ${CYAN}Ingrese el puerto de MySQL [${BOLD}$DEFAULT_PORT${NC}${CYAN}]: ${NC})" MYSQL_PORT_HOST
MYSQL_PORT_HOST=${MYSQL_PORT_HOST:-$DEFAULT_PORT}
print_success "Puerto MySQL: $MYSQL_PORT_HOST"

#-------------------------------------URL DE REPOSITORIOS--------------------------------------------------------------
URL_API='https://gitlab.torresoftware.com/TorreSoftware/apidian-laravel-8-s3.git'

#-------------------------------------RUTA DE INSTALACION (RUTA ACTUAL DEL SCRIPT)-------------------------------------
PATH_CURRENT=$(echo $PWD)

#-------------------------------------NOMBRE DE CARPETAS----------------------------------------------------------------
DIR_API='apidian'

#-------------------------------------SET DATA--------------------------------------------------------------------------
generate_password() {
    head /dev/urandom | tr -dc A-Za-z0-9 | head -c "$1" ; echo ''
}

print_step "Generando contraseñas seguras"
MYSQL_ROOT_PASSWORD=$(generate_password 20)
MYSQL_API_PASSWORD=$(generate_password 20)
print_success "Contraseñas generadas correctamente"

#-------------------------------------SET .env--------------------------------------------------------------------------
print_step "Creando archivo de configuración (.env)"
cat << EOF > $PATH_CURRENT/.env
MYSQL_ROOT_PASSWORD=$MYSQL_ROOT_PASSWORD
MYSQL_PORT_HOST=$MYSQL_PORT_HOST
SERVER_IP=$SERVER_IP
EOF
print_success "Archivo .env creado"

#-------------------------------------INSTALACION DE DEPENDENCIAS-----------------------------------------------------------
print_step "Instalando dependencias del sistema"
print_warning "Este proceso puede tomar 3-5 minutos, por favor espera..."
echo ""

if run_with_spinner "apt-get -y update" "Paso 1/4: Actualizando repositorios de Ubuntu..." 180; then
    print_success "Repositorios actualizados"
else
    print_error "Error actualizando repositorios"
    exit 1
fi

if run_with_spinner "apt-get -y install git-core zip unzip apt-transport-https ca-certificates curl gnupg-agent software-properties-common" "Paso 2/4: Instalando paquetes base (git, curl, etc.)..." 300; then
    print_success "Paquetes base instalados"
else
    print_error "Error instalando paquetes base"
    exit 1
fi

print_info "Paso 3/4: Configurando repositorio de Docker (puede tardar 1-2 minutos)..."
print_info "Descargando clave GPG de Docker..."

if curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - 2>&1 | grep -q "OK"; then
    print_success "Clave GPG añadida"
else
    print_warning "Usando método alternativo para clave GPG..."
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
fi

print_info "Agregando repositorio de Docker..."
if add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" -y 2>&1; then
    print_success "Repositorio agregado"
else
    print_error "Error al agregar repositorio de Docker"
    print_info "Verifica la conectividad a Internet"
    exit 1
fi

if run_with_spinner "apt-get -y update" "Actualizando índice de paquetes..." 180; then
    print_success "Repositorio de Docker configurado"
else
    print_warning "Actualización con advertencias, continuando..."
fi

if run_with_spinner "apt-get -y install docker-ce" "Paso 4/4: Instalando Docker CE (puede tardar 2-3 minutos)..." 300; then
    systemctl start docker
    systemctl enable docker > /dev/null 2>&1
    print_success "Docker CE instalado y configurado"
else
    print_error "Error instalando Docker CE"
    exit 1
fi

print_info "Descargando Docker Compose v2.24.0..."
# Detectar arquitectura
ARCH=$(uname -m)
if [ "$ARCH" = "x86_64" ]; then
    COMPOSE_ARCH="x86_64"
elif [ "$ARCH" = "aarch64" ]; then
    COMPOSE_ARCH="aarch64"
else
    COMPOSE_ARCH="x86_64"
fi

# Descargar Docker Compose v2 (versión moderna compatible con API 1.44)
curl -SL "https://github.com/docker/compose/releases/download/v2.24.0/docker-compose-linux-${COMPOSE_ARCH}" -o /usr/local/bin/docker-compose 2>/dev/null
chmod +x /usr/local/bin/docker-compose

# Verificar instalación
if docker-compose version > /dev/null 2>&1; then
    COMPOSE_VERSION=$(docker-compose version --short 2>/dev/null || echo "2.24.0")
    print_success "Docker Compose v${COMPOSE_VERSION} instalado correctamente"
else
    print_error "Error al instalar Docker Compose"
    exit 1
fi

print_info "Creando red Docker 'proxynet'..."
docker network create proxynet > /dev/null 2>&1 || print_warning "Red 'proxynet' ya existe"
print_success "Red Docker configurada"

#-------------------------------------ESTRUCTURA DEL PROYECTO----------------------------------------------------------------
print_step "Creando estructura de directorios"
mkdir -p "$PATH_CURRENT/setup/mysql" "$PATH_CURRENT/setup/fpms/$DIR_API"
print_success "Directorios creados: setup/mysql, setup/fpms"

print_info "Generando script de inicialización de MySQL..."
cat << EOF > $PATH_CURRENT/setup/mysql/init.sql
CREATE DATABASE IF NOT EXISTS $DIR_API;

CREATE USER '$DIR_API'@'%' IDENTIFIED BY '$MYSQL_API_PASSWORD';

GRANT ALL PRIVILEGES ON $DIR_API.* TO '$DIR_API'@'%';
FLUSH PRIVILEGES;
EOF
print_success "Script de inicialización MySQL creado"

#-------------------------------------CLONANDO API--------------------------------------------------------------------------
print_step "Clonando repositorio de la aplicación"
print_info "Repositorio: $URL_API"
print_warning "Esto puede tardar 1-3 minutos dependiendo del tamaño del repositorio..."

if git clone $URL_API $PATH_CURRENT/$DIR_API 2>&1 | grep -q "done"; then
    print_success "Repositorio clonado exitosamente"
else
    # Si falla sin output, intentar con credenciales interactivas
    if [ ! -d "$PATH_CURRENT/$DIR_API" ]; then
        print_warning "Se requieren credenciales de GitLab"
        git clone $URL_API $PATH_CURRENT/$DIR_API
        if [ $? -eq 0 ]; then
            print_success "Repositorio clonado exitosamente"
        else
            print_error "Error al clonar el repositorio"
            print_warning "Verifica las credenciales de GitLab y la conectividad"
            exit 1
        fi
    fi
fi

#-------------------------------------DOCKER/PHP8/Dockerfile--------------------------------------------------------------------------
print_step "Verificando Dockerfile de PHP 8.0"
cd "$PATH_CURRENT/$DIR_API"

if [ ! -d "docker" ]; then
    print_info "Creando estructura docker/php8..."
    mkdir -p docker/php8
fi

if [ ! -f "docker/php8/Dockerfile" ]; then
    print_warning "Dockerfile no encontrado, creando uno personalizado..."
    cat << 'DOCKERFILECONTENT' > docker/php8/Dockerfile
FROM php:8.0-fpm

RUN apt-get update && apt-get install -y --no-install-recommends \
    libpng-dev \
    libjpeg-dev \
    libfreetype6-dev \
    libzip-dev \
    libicu-dev \
    libxml2-dev \
    curl \
    git \
    unzip \
    && docker-php-ext-configure gd --with-freetype --with-jpeg \
    && docker-php-ext-install -j$(nproc) gd pdo_mysql mysqli mbstring zip intl soap opcache \
    && pecl install redis \
    && docker-php-ext-enable redis \
    && curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer \
    && apt-get clean && rm -rf /var/lib/apt/lists/*

WORKDIR /var/www/html
DOCKERFILECONTENT
    print_success "Dockerfile creado"
else
    print_success "Dockerfile encontrado en docker/php8/"
fi

print_info "Descomprimiendo directorio storage..."
unzip -o storage.zip > /dev/null 2>&1
print_success "Directorio storage configurado"

#-------------------------------------SET docker-compose PRINCIPAL-------------------------------------------------------
print_step "Generando archivo docker-compose.yml"
cd $PATH_CURRENT
cat << EOF > $PATH_CURRENT/docker-compose.yml
version: '3.3'

services:
  nginx_api:
    image: nginx:alpine
    working_dir: /var/www/html
    ports:
      - "80:80"
    volumes:
      - $PATH_CURRENT/$DIR_API:/var/www/html
      - $PATH_CURRENT/setup/fpms/$DIR_API/default:/etc/nginx/conf.d/default.conf
    restart: unless-stopped
    depends_on:
      - php_api
    networks:
      - webnet

  php_api:
    build:
      context: $PATH_CURRENT/$DIR_API/docker/php8
      dockerfile: Dockerfile
    working_dir: /var/www/html
    volumes:
      - $PATH_CURRENT/$DIR_API:/var/www/html
    restart: unless-stopped
    depends_on:
      - mariadb
    networks:
      - webnet

  mariadb:
    image: mariadb:10.5.6
    environment:
      - MYSQL_ROOT_PASSWORD=$MYSQL_ROOT_PASSWORD
    ports:
      - "$MYSQL_PORT_HOST:3306"
    volumes:
      - mysqldata:/var/lib/mysql
      - $PATH_CURRENT/setup/mysql/init.sql:/docker-entrypoint-initdb.d/init.sql
    restart: unless-stopped
    networks:
      - webnet

networks:
  webnet:
    name: proxynet
    external: true

volumes:
  mysqldata:
    driver: "local"
  redisdata:
    driver: "local"
EOF

print_success "Docker Compose configurado con 3 servicios: Nginx, PHP 8.0, MariaDB"
print_info "Nota: Sin proxy reverso - acceso directo por IP"

#-------------------------------------SET API .conf--------------------------------------------------------------
print_step "Configurando servidor web Nginx"
cat << EOF > $PATH_CURRENT/setup/fpms/$DIR_API/default
server {
    listen 80 default_server;
    root /var/www/html/public;
    index index.html index.htm index.php;
    server_name _;
    charset utf-8;
    server_tokens off;
    client_max_body_size 100M;

    location = /favicon.ico {
        log_not_found off;
        access_log off;
    }
    location = /robots.txt {
        log_not_found off;
        access_log off;
    }
    location / {
        try_files \$uri \$uri/ /index.php\$is_args\$args;
    }
    location ~ \.php$\$ {
        fastcgi_split_path_info ^(.+\.php)(/.+)\$;
        fastcgi_pass php_api:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME \$document_root\$fastcgi_script_name;
        fastcgi_param PATH_INFO \$fastcgi_path_info;
        fastcgi_buffering off;
        fastcgi_read_timeout 300;
    }
    error_page 404 /index.php;
    location ~ /\.ht {
        deny all;
    }
    location ~ /\.(?!well-known).* {
        deny all;
    }
}
EOF

print_success "Configuración de Nginx creada (acepta cualquier IP)"

print_step "Iniciando contenedores Docker"
echo -e "${YELLOW}⏳ Este es el paso más largo: puede tomar 5-10 minutos${NC}"
echo -e "${CYAN}   • Descargando imágenes base de Docker Hub${NC}"
echo -e "${CYAN}   • Compilando extensiones PHP (gd, intl, soap, redis, etc.)${NC}"
echo -e "${CYAN}   • Instalando Composer${NC}"
echo -e "${CYAN}   • Iniciando MariaDB, Nginx y PHP-FPM${NC}"
echo ""
print_info "Por favor espera, el proceso está en marcha..."

if docker-compose up -d; then
    print_success "Contenedores iniciados correctamente"
else
    print_error "Error al iniciar contenedores"
    exit 1
fi

print_info "Esperando que los contenedores se inicien (15 segundos)..."
sleep 15

print_info "Verificando que MariaDB esté completamente lista..."
echo -e "${CYAN}   Esto puede tomar hasta 2 minutos en el primer inicio...${NC}"

# Esperar a que MariaDB esté lista para aceptar conexiones
MARIADB_READY=false
for i in {120..1}; do
    # Verificar que el contenedor está ejecutándose
    if ! docker-compose ps mariadb | grep -q "Up"; then
        echo -ne "\r${YELLOW}   MariaDB iniciando... ${i}s ${NC}"
        sleep 1
        continue
    fi

    # Verificar que acepta conexiones
    if docker-compose exec -T mariadb mysqladmin ping -h localhost -uroot -p$MYSQL_ROOT_PASSWORD 2>/dev/null | grep -q "mysqld is alive"; then
        echo ""
        print_success "MariaDB está lista y aceptando conexiones"
        MARIADB_READY=true
        break
    fi

    echo -ne "\r${CYAN}   Esperando que MariaDB acepte conexiones... ${i}s ${NC}"
    sleep 1

    if [ $i -eq 1 ]; then
        echo ""
        print_error "MariaDB no responde después de 2 minutos"
        print_info "Estado de contenedores:"
        docker-compose ps
        echo ""
        print_info "Últimas líneas del log de MariaDB:"
        docker-compose logs --tail=30 mariadb
        exit 1
    fi
done
echo ""

# Verificación adicional de la base de datos
if [ "$MARIADB_READY" = true ]; then
    print_info "Verificando que la base de datos '$DIR_API' existe..."
    if docker-compose exec -T mariadb mysql -uroot -p$MYSQL_ROOT_PASSWORD -e "USE $DIR_API; SELECT 1;" > /dev/null 2>&1; then
        print_success "Base de datos '$DIR_API' está disponible"
    else
        print_error "Base de datos '$DIR_API' no está disponible"
        print_info "Intentando crear manualmente..."
        docker-compose exec -T mariadb mysql -uroot -p$MYSQL_ROOT_PASSWORD -e "CREATE DATABASE IF NOT EXISTS $DIR_API;"
        docker-compose exec -T mariadb mysql -uroot -p$MYSQL_ROOT_PASSWORD -e "GRANT ALL PRIVILEGES ON $DIR_API.* TO '$DIR_API'@'%';"
    fi
fi

#-------------------------------------ajustes api-------------------------------------------------------
print_step "Configurando aplicación Laravel"

print_info "Actualizando Composer..."
docker-compose exec -T php_api composer self-update > /dev/null 2>&1
print_success "Composer actualizado"

echo -e "${YELLOW}⏳ Instalando dependencias PHP con Composer (3-5 minutos)...${NC}"
print_info "Descargando paquetes de Laravel, Guzzle, PHPUnit, etc..."
docker-compose exec -T php_api composer install --no-interaction
print_success "Dependencias instaladas"

print_info "Copiando archivos URN y plantillas XML..."

# Verificar si existen archivos URN antes de copiar
if docker-compose exec -T php_api test -d resources/templates/xml/urn 2>/dev/null; then
    docker-compose exec -T php_api bash -c 'cp resources/templates/xml/urn/*.* resources/templates/xml 2>/dev/null || true'
    print_success "Plantillas XML copiadas"
else
    print_warning "Directorio urn no encontrado, omitiendo copia de plantillas"
fi

if docker-compose exec -T php_api test -d vendor/ubl21dian/torresoftware/src/XAdES/urn 2>/dev/null; then
    docker-compose exec -T php_api bash -c 'cp vendor/ubl21dian/torresoftware/src/XAdES/urn/*.* vendor/ubl21dian/torresoftware/src/XAdES 2>/dev/null || true'
    print_success "Archivos XAdES copiados"
else
    print_warning "Directorio XAdES/urn no encontrado, omitiendo copia"
fi

if docker-compose exec -T php_api test -f resources/templates/xml/urn/Request.php 2>/dev/null; then
    docker-compose exec -T php_api cp resources/templates/xml/urn/Request.php vendor/laravel/framework/src/Illuminate/Http/Request.php
    print_success "Request.php personalizado copiado"
else
    print_warning "Request.php personalizado no encontrado, usando el original de Laravel"
fi

print_info "Estableciendo permisos de escritura..."
docker-compose exec -T php_api chmod -R 777 vendor/mpdf/mpdf storage bootstrap/cache
print_success "Permisos configurados"

#-------------------------------------CONFIGURAR .env DESPUES DE COMPOSER INSTALL--------------------------------------
print_step "Configurando variables de entorno de la aplicación"
print_info "Actualizando archivo .env con configuración de base de datos..."

docker-compose exec -T php_api bash -c "cat > /var/www/html/.env << 'ENVEOF'
APP_NAME=Laravel
APP_ENV=production
APP_KEY=
APP_DEBUG=false
APP_URL=http://$SERVER_IP

LOG_CHANNEL=stack
LOG_DEPRECATIONS_CHANNEL=null
LOG_LEVEL=debug

DB_CONNECTION=mysql
DB_HOST=mariadb
DB_PORT=3306
DB_DATABASE=$DIR_API
DB_USERNAME=$DIR_API
DB_PASSWORD=$MYSQL_API_PASSWORD

BROADCAST_DRIVER=log
CACHE_DRIVER=file
FILESYSTEM_DRIVER=local
QUEUE_CONNECTION=sync
SESSION_DRIVER=file
SESSION_LIFETIME=120

MEMCACHED_HOST=127.0.0.1

REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

MAIL_MAILER=smtp
MAIL_HOST=mailhog
MAIL_PORT=1025
MAIL_USERNAME=null
MAIL_PASSWORD=null
MAIL_ENCRYPTION=null
MAIL_FROM_ADDRESS=null
MAIL_FROM_NAME=\"\${APP_NAME}\"

AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
AWS_DEFAULT_REGION=us-east-1
AWS_BUCKET=
AWS_USE_PATH_STYLE_ENDPOINT=false

PUSHER_APP_ID=
PUSHER_APP_KEY=
PUSHER_APP_SECRET=
PUSHER_APP_CLUSTER=mt1

MIX_PUSHER_APP_KEY=\"\${PUSHER_APP_KEY}\"
MIX_PUSHER_APP_CLUSTER=\"\${PUSHER_APP_CLUSTER}\"

FORCE_HTTPS=false
ENVEOF
"

print_success "Archivo .env configurado"

print_info "Verificando que el archivo .env se creó correctamente..."
if docker-compose exec -T php_api test -f .env; then
    print_success "Archivo .env existe"
    docker-compose exec -T php_api grep "^DB_" .env
else
    print_error "El archivo .env no se creó"
    exit 1
fi

print_info "Limpiando cache de configuración de Laravel..."
docker-compose exec -T php_api php artisan config:clear > /dev/null 2>&1
docker-compose exec -T php_api php artisan cache:clear > /dev/null 2>&1
print_success "Cache limpiado"

# Verificar conectividad desde PHP a MariaDB
print_info "Verificando conectividad desde PHP a MariaDB..."
RETRY_COUNT=0
MAX_RETRIES=30

while [ $RETRY_COUNT -lt $MAX_RETRIES ]; do
    if docker-compose exec -T php_api php -r "
        try {
            \$pdo = new PDO('mysql:host=mariadb;port=3306', 'root', '${MYSQL_ROOT_PASSWORD}');
            echo 'OK';
            exit(0);
        } catch (Exception \$e) {
            exit(1);
        }
    " 2>/dev/null | grep -q "OK"; then
        print_success "Conectividad PHP → MariaDB verificada"
        break
    fi

    RETRY_COUNT=$((RETRY_COUNT + 1))
    echo -ne "\r${CYAN}   Intentando conectar desde PHP... ${RETRY_COUNT}/${MAX_RETRIES} ${NC}"
    sleep 2

    if [ $RETRY_COUNT -eq $MAX_RETRIES ]; then
        echo ""
        print_error "No se pudo establecer conexión desde PHP a MariaDB"
        print_info "Diagnóstico:"
        docker-compose exec -T php_api php artisan config:cache
        docker-compose exec -T php_api php -r "echo 'DB_HOST: ' . getenv('DB_HOST') . PHP_EOL;"
        docker-compose exec -T php_api php -r "echo 'DB_PORT: ' . getenv('DB_PORT') . PHP_EOL;"
        exit 1
    fi
done
echo ""

print_info "Verificando configuración de base de datos..."
docker-compose exec -T php_api php -r "
    require '/var/www/html/vendor/autoload.php';
    \$app = require_once '/var/www/html/bootstrap/app.php';
    \$app->make('Illuminate\Contracts\Console\Kernel')->bootstrap();
    echo 'DB_HOST: ' . config('database.connections.mysql.host') . PHP_EOL;
    echo 'DB_PORT: ' . config('database.connections.mysql.port') . PHP_EOL;
    echo 'DB_DATABASE: ' . config('database.connections.mysql.database') . PHP_EOL;
    echo 'DB_USERNAME: ' . config('database.connections.mysql.username') . PHP_EOL;
"
print_success "Configuración verificada"

print_info "Ejecutando migraciones y seeders de base de datos (1-2 minutos)..."

if docker-compose exec -T php_api php artisan migrate:refresh --seed --force; then
    print_success "Base de datos inicializada correctamente"
else
    print_error "Error al ejecutar migraciones"
    print_warning "Esperando 10 segundos adicionales y reintentando..."
    sleep 10

    print_warning "Reintentando migraciones sin --seed..."
    if docker-compose exec -T php_api php artisan migrate:fresh --force; then
        print_success "Migraciones ejecutadas (sin seeders)"
        print_warning "Los seeders fallaron, pero la base de datos está lista"
    else
        print_error "Error crítico en migraciones después de reintentos"
        echo ""
        print_info "Diagnóstico completo:"
        print_info "═══════════════════════════════════════════════════════"
        echo ""
        print_info "1. Estado de contenedores:"
        docker-compose ps
        echo ""
        print_info "2. Contenido del .env:"
        docker-compose exec -T php_api grep "^DB_" .env
        echo ""
        print_info "3. Configuración cargada de Laravel:"
        docker-compose exec -T php_api php -r "
            require '/var/www/html/vendor/autoload.php';
            \$app = require_once '/var/www/html/bootstrap/app.php';
            \$app->make('Illuminate\Contracts\Console\Kernel')->bootstrap();
            echo 'DB_HOST: ' . config('database.connections.mysql.host') . PHP_EOL;
            echo 'DB_DATABASE: ' . config('database.connections.mysql.database') . PHP_EOL;
            echo 'DB_USERNAME: ' . config('database.connections.mysql.username') . PHP_EOL;
        "
        echo ""
        print_info "4. Test de conexión manual:"
        docker-compose exec -T php_api php -r "
            try {
                \$pdo = new PDO('mysql:host=mariadb;dbname=$DIR_API', '$DIR_API', '$MYSQL_API_PASSWORD');
                echo '✓ Conexión exitosa a base de datos $DIR_API' . PHP_EOL;
            } catch (Exception \$e) {
                echo '✗ Error: ' . \$e->getMessage() . PHP_EOL;
            }
        "
        echo ""
        print_info "═══════════════════════════════════════════════════════"
        exit 1
    fi
fi

print_info "Generando clave de aplicación..."
docker-compose exec -T php_api php artisan key:generate
print_success "Clave de aplicación generada"

print_info "Creando enlaces simbólicos de storage..."
docker-compose exec -T php_api php artisan storage:link
print_success "Storage enlazado"

print_info "Limpiando caché de Laravel..."
docker-compose exec -T php_api php artisan optimize:clear
print_success "Caché limpiado"

#-------------------------------------CONFIGURAR OPENSSL 3 LEGACY OPTION-------------------------------------------------
print_step "Verificando version de OpenSSL en el contenedor"

# Detectar version de OpenSSL dentro del contenedor
OPENSSL_VERSION=$(docker-compose exec -T php_api openssl version | grep -oP '\d+\.\d+\.\d+' | head -n1)
OPENSSL_MAJOR=$(echo "$OPENSSL_VERSION" | cut -d. -f1)

print_info "OpenSSL version detectada: $OPENSSL_VERSION"

if [ "$OPENSSL_MAJOR" -ge 3 ]; then
    print_info "OpenSSL 3+ detectado - Configurando legacy provider..."
    print_info "Esto permite usar algoritmos legacy necesarios para firma digital DIAN..."

    # Crear script de configuracion dentro del contenedor PHP
    docker-compose exec -T php_api bash -c 'cat > /tmp/configure_openssl.sh << '\''OPENSSLSCRIPT'\''
#!/bin/bash

OPENSSL_CONF="/etc/ssl/openssl.cnf"

# Hacer backup del archivo original
cp $OPENSSL_CONF ${OPENSSL_CONF}.backup

# Verificar si ya existe la sección [legacy_sect]
if grep -q "\[legacy_sect\]" $OPENSSL_CONF; then
    echo "✓ OpenSSL legacy ya está configurado"
else
    echo "Configurando OpenSSL legacy support..."

    # Agregar configuración legacy si no existe [provider_sect]
    if ! grep -q "\[provider_sect\]" $OPENSSL_CONF; then
        cat >> $OPENSSL_CONF << EOF

# Legacy provider configuration
[provider_sect]
default = default_sect
legacy = legacy_sect

[default_sect]
activate = 1

[legacy_sect]
activate = 1
EOF
    else
        # Si existe [provider_sect], actualizarla
        sed -i "/\[provider_sect\]/a legacy = legacy_sect" $OPENSSL_CONF

        # Verificar y agregar [default_sect] si no existe
        if ! grep -q "\[default_sect\]" $OPENSSL_CONF; then
            cat >> $OPENSSL_CONF << EOF

[default_sect]
activate = 1
EOF
        fi

        # Agregar [legacy_sect] si no existe
        if ! grep -q "\[legacy_sect\]" $OPENSSL_CONF; then
            cat >> $OPENSSL_CONF << EOF

[legacy_sect]
activate = 1
EOF
        fi
    fi

    # Asegurar que openssl_conf apunta a la configuración correcta
    if ! grep -q "^openssl_conf = openssl_init" $OPENSSL_CONF; then
        sed -i "1i openssl_conf = openssl_init" $OPENSSL_CONF
    fi

    # Agregar sección [openssl_init] si no existe
    if ! grep -q "\[openssl_init\]" $OPENSSL_CONF; then
        sed -i "/^openssl_conf = openssl_init/a \\\n[openssl_init]\\\nproviders = provider_sect" $OPENSSL_CONF
    fi

    echo "✓ OpenSSL legacy support configurado"
fi
OPENSSLSCRIPT
'

    # Ejecutar el script de configuracion
    print_info "Ejecutando configuracion de OpenSSL..."
    docker-compose exec -T php_api bash /tmp/configure_openssl.sh

    # Reiniciar PHP-FPM para aplicar cambios
    print_info "Reiniciando PHP-FPM para aplicar cambios..."
    docker-compose restart php_api > /dev/null 2>&1

    # Reiniciar Nginx
    print_info "Reiniciando Nginx..."
    docker-compose restart nginx_api > /dev/null 2>&1

    print_success "OpenSSL 3 legacy support activado correctamente"
else
    print_success "OpenSSL $OPENSSL_VERSION no requiere legacy provider"
    print_info "Los algoritmos legacy estan disponibles por defecto en OpenSSL 1.x"
fi

print_step "Finalizando despliegue"

print_info "Generando archivo de credenciales..."
cat << EOF > $PATH_CURRENT/setup/private.txt
MYSQL
----------------------------------
DB_PORT     = $MYSQL_PORT_HOST
DB_USERNAME = root
DB_PASSWORD = $MYSQL_ROOT_PASSWORD

API
----------------------------------
PATH = $PATH_CURRENT/$DIR_API
URL  = http://$SERVER_IP

EOF

print_success "Archivo de credenciales creado en: $PATH_CURRENT/setup/private.txt"

echo ""
echo -e "${GREEN}${BOLD}╔═══════════════════════════════════════════════════════════════╗${NC}"
echo -e "${GREEN}${BOLD}║                                                               ║${NC}"
echo -e "${GREEN}${BOLD}║  ✓  INSTALACIÓN COMPLETADA EXITOSAMENTE                       ║${NC}"
echo -e "${GREEN}${BOLD}║                                                               ║${NC}"
echo -e "${GREEN}${BOLD}╚═══════════════════════════════════════════════════════════════╝${NC}"
echo ""
echo -e "${CYAN}${BOLD}📋 CREDENCIALES DE ACCESO:${NC}"
echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
cat $PATH_CURRENT/setup/private.txt
echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${BLUE}🌐 URL de acceso:${NC}"
echo -e "   ${BOLD}http://$SERVER_IP${NC}"
echo ""
echo -e "${YELLOW}⚠️  IMPORTANTE:${NC}"
echo -e "   ${YELLOW}• Acceso configurado solo por HTTP (puerto 80)${NC}"
echo -e "   ${YELLOW}• NO se instaló certificado SSL (no soportado sin dominio)${NC}"
echo -e "   ${YELLOW}• Guarda las credenciales en: ${BOLD}$PATH_CURRENT/setup/private.txt${NC}"
echo ""
echo -e "${BLUE}📦 Contenedores en ejecución:${NC}"
docker ps --format "   • {{.Names}} - {{.Status}}"
echo ""

# Verificar conectividad
echo -e "${BLUE}🔍 Verificando conectividad...${NC}"
sleep 3
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" http://$SERVER_IP 2>/dev/null || echo "000")
if [ "$HTTP_CODE" = "200" ] || [ "$HTTP_CODE" = "302" ] || [ "$HTTP_CODE" = "301" ]; then
    echo -e "   ${GREEN}✓ Sitio web accesible (HTTP $HTTP_CODE)${NC}"
    echo ""
    echo -e "${GREEN}✓ Instalación finalizada correctamente${NC}"
    echo ""
    echo -e "   ${GREEN}✓ Puedes acceder a: http://$SERVER_IP${NC}"
else
    echo -e "   ${YELLOW}⚠ Sitio no responde inmediatamente (puede necesitar 1-2 minutos)${NC}"
    echo -e "   ${YELLOW}  Si persiste, ejecuta: docker-compose restart${NC}"
fi
echo ""

echo -e "${GREEN}✓ Instalación finalizada correctamente${NC}"
echo ""