#!/bin/bash

# ========================================
# Script: create-new-project.sh
# Descripción: Crea un nuevo proyecto completo desde cero
#              Solicita el nombre del proyecto y automatiza todo el proceso
# Uso: ./create-new-project.sh [--json archivo.json]
#      ./create-new-project.sh --json mi-proyecto.json
# ========================================

# Colores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
PURPLE='\033[0;35m'
NC='\033[0m' # No Color

# Función para mostrar mensajes con colores
print_message() {
    echo -e "${GREEN}[INFO]${NC} $1"
}

print_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

print_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

print_step() {
    echo -e "${BLUE}[STEP]${NC} $1"
}

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

print_question() {
    echo -e "${CYAN}[?]${NC} $1"
}

# Variables globales
JSON_FILE=""
HAS_JQ=false

# Verificar si jq está instalado
if command -v jq &> /dev/null; then
    HAS_JQ=true
fi

# Función para leer valores del JSON
read_json_value() {
    local path=$1
    local json_file=$2
    if [ "$HAS_JQ" = true ]; then
        jq -r "$path // empty" "$json_file" 2>/dev/null
    else
        echo ""
    fi
}

# Función para mostrar ayuda
print_help() {
    cat <<EOF
Uso:
  ./create-new-project.sh [opciones]

Opciones:
  --json FILE       Leer configuración desde archivo JSON
  --config FILE     Alias de --json
  --help            Muestra esta ayuda

Ejemplo:
  ./create-new-project.sh --json mi-proyecto.json
  ./create-new-project.sh  (modo interactivo)

Template JSON:
  Copia scripts/local-project-template.json y edítalo con tus datos
EOF
}

# Verificar que estamos en el directorio cd-system
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CD_SYSTEM_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"

if [ ! -f "$CD_SYSTEM_DIR/artisan" ] || [ ! -d "$CD_SYSTEM_DIR/app" ]; then
    print_error "Este script debe ejecutarse desde el repositorio cd-system"
    print_message "O desde un directorio donde cd-system esté en el directorio padre"
    exit 1
fi

# Detectar directorio padre (htdocs)
PARENT_DIR="$(cd "$CD_SYSTEM_DIR/.." && pwd)"
CLONE_SCRIPT="$CD_SYSTEM_DIR/scripts/clone-to-new-repo.sh"

if [ ! -f "$CLONE_SCRIPT" ]; then
    print_error "No se encuentra el script clone-to-new-repo.sh"
    print_message "Esperado en: $CLONE_SCRIPT"
    exit 1
fi

print_message "═══════════════════════════════════════════════════════════"
print_message "Crear Nuevo Proyecto desde CD-System"
print_message "═══════════════════════════════════════════════════════════"
echo
print_message "Directorio CD-System: ${CYAN}$CD_SYSTEM_DIR${NC}"
print_message "Directorio de proyectos: ${CYAN}$PARENT_DIR${NC}"
echo

# Procesar argumentos
while [[ $# -gt 0 ]]; do
    case "$1" in
        --json|--config)
            JSON_FILE="$2"
            shift 2
            ;;
        --help)
            print_help
            exit 0
            ;;
        *)
            print_error "Opción desconocida: $1"
            print_help
            exit 1
            ;;
    esac
done

# Si se proporcionó JSON, leer valores
if [ -n "$JSON_FILE" ]; then
    if [ "$HAS_JQ" = false ]; then
        print_error "jq no está instalado. Es necesario para usar archivos JSON."
        print_message "Instala jq con: brew install jq (macOS) o apt-get install jq (Linux)"
        exit 1
    fi

    # Buscar el archivo JSON en varios lugares posibles
    JSON_FOUND=""
    if [ -f "$JSON_FILE" ]; then
        # Ruta absoluta o relativa directa
        JSON_FOUND="$JSON_FILE"
    elif [ -f "$CD_SYSTEM_DIR/$JSON_FILE" ]; then
        # En el directorio cd-system
        JSON_FOUND="$CD_SYSTEM_DIR/$JSON_FILE"
    elif [ -f "$SCRIPT_DIR/$JSON_FILE" ]; then
        # En el directorio scripts
        JSON_FOUND="$SCRIPT_DIR/$JSON_FILE"
    elif [ -f "$(pwd)/$JSON_FILE" ]; then
        # En el directorio actual
        JSON_FOUND="$(pwd)/$JSON_FILE"
    fi

    if [ -z "$JSON_FOUND" ] || [ ! -f "$JSON_FOUND" ]; then
        print_error "Archivo JSON no encontrado: $JSON_FILE"
        print_message "Buscado en:"
        print_message "  - $JSON_FILE"
        print_message "  - $CD_SYSTEM_DIR/$JSON_FILE"
        print_message "  - $SCRIPT_DIR/$JSON_FILE"
        print_message "  - $(pwd)/$JSON_FILE"
        exit 1
    fi

    JSON_FILE="$JSON_FOUND"
    print_message "Archivo JSON encontrado: $JSON_FILE"

    if ! jq empty "$JSON_FILE" 2>/dev/null; then
        print_error "El archivo JSON no es válido: $JSON_FILE"
        exit 1
    fi

    print_success "Modo JSON activado. Leyendo configuración desde: $JSON_FILE"

    # Leer valores del JSON
    PROJECT_NAME=$(read_json_value ".project.name" "$JSON_FILE")
    REPO_URL=$(read_json_value ".project.repository_url" "$JSON_FILE")
    BRANCH=$(read_json_value ".project.branch" "$JSON_FILE")
    ASSETS_PATH=$(read_json_value ".assets.assets_path" "$JSON_FILE")
    HAS_ASSETS=$(read_json_value ".assets.has_assets" "$JSON_FILE")

    # Valores por defecto si están vacíos o son "null"
    if [ -z "$PROJECT_NAME" ] || [ "$PROJECT_NAME" = "null" ]; then
        print_error "El campo 'project.name' es requerido en el JSON"
        exit 1
    fi

    if [ -z "$REPO_URL" ] || [ "$REPO_URL" = "null" ]; then
        REPO_URL="https://github.com/LACOMPANIADIGITAL/$PROJECT_NAME.git"
    fi

    BRANCH=${BRANCH:-"cd-system"}

    if [ -z "$ASSETS_PATH" ] || [ "$ASSETS_PATH" = "null" ]; then
        ASSETS_PATH="$HOME/Desktop/assets-$PROJECT_NAME"
    else
        # Expandir ~ si existe
        ASSETS_PATH="${ASSETS_PATH/#\~/$HOME}"
    fi

    if [ "$HAS_ASSETS" != "true" ]; then
        HAS_ASSETS=false
    fi

    print_message "Valores leídos del JSON:"
    print_message "  Nombre: $PROJECT_NAME"
    print_message "  Repositorio: $REPO_URL"
    print_message "  Rama: $BRANCH"
    print_message "  Assets: $ASSETS_PATH"
    echo
else
    # Modo interactivo (original)
    # Solicitar nombre del proyecto
    print_question "Ingresa el nombre del proyecto (ej: pedroweb, cokecolombres):"
    read -p "> " PROJECT_NAME

    if [ -z "$PROJECT_NAME" ]; then
        print_error "El nombre del proyecto no puede estar vacío"
        exit 1
    fi

    # Validar nombre del proyecto (solo letras, números, guiones y guiones bajos)
    if [[ ! "$PROJECT_NAME" =~ ^[a-zA-Z0-9_-]+$ ]]; then
        print_error "El nombre del proyecto solo puede contener letras, números, guiones y guiones bajos"
        exit 1
    fi

    PROJECT_REPO="https://github.com/LACOMPANIADIGITAL/$PROJECT_NAME.git"

    # Confirmar URL del repositorio
    echo
    print_question "URL del repositorio en GitHub:"
    print_message "Por defecto: ${CYAN}$PROJECT_REPO${NC}"
    read -p "Presiona Enter para usar el default o ingresa una URL diferente: " REPO_URL

    if [ -z "$REPO_URL" ]; then
        REPO_URL="$PROJECT_REPO"
    fi

    # Validar URL
    if [[ ! "$REPO_URL" =~ ^https://github.com/ ]]; then
        print_warning "La URL no parece ser de GitHub, pero continuaremos..."
    fi

    # Solicitar ruta de assets
    echo
    print_question "Ruta de assets del proyecto (ej: ~/Desktop/assets-$PROJECT_NAME):"
    print_message "Presiona Enter para usar: ${CYAN}~/Desktop/assets-$PROJECT_NAME${NC}"
    read -p "O ingresa una ruta diferente: " ASSETS_PATH

    # Expandir ~ y usar default si está vacío
    if [ -z "$ASSETS_PATH" ]; then
        ASSETS_PATH="$HOME/Desktop/assets-$PROJECT_NAME"
    else
        # Expandir ~ si existe
        ASSETS_PATH="${ASSETS_PATH/#\~/$HOME}"
    fi

    BRANCH="cd-system"
fi

# Validar nombre del proyecto (solo letras, números, guiones y guiones bajos)
if [[ ! "$PROJECT_NAME" =~ ^[a-zA-Z0-9_-]+$ ]]; then
    print_error "El nombre del proyecto solo puede contener letras, números, guiones y guiones bajos"
    exit 1
fi

PROJECT_DIR="$PARENT_DIR/$PROJECT_NAME"

# Verificar si el directorio ya existe
if [ -d "$PROJECT_DIR" ]; then
    print_warning "El directorio '$PROJECT_DIR' ya existe"
    if [ -z "$JSON_FILE" ]; then
        read -p "¿Deseas eliminarlo y empezar de nuevo? (y/N): " -n 1 -r
        echo
        if [[ $REPLY =~ ^[Yy]$ ]]; then
            print_step "Eliminando directorio existente..."
            rm -rf "$PROJECT_DIR"
            print_success "Directorio eliminado"
        else
            print_message "Operación cancelada"
            exit 0
        fi
    else
        # En modo JSON, eliminar automáticamente si existe
        print_step "Eliminando directorio existente (modo JSON)..."
        rm -rf "$PROJECT_DIR"
        print_success "Directorio eliminado"
    fi
fi

# Verificar si existe la carpeta de assets
ASSETS_PROVIDED=false
if [ -d "$ASSETS_PATH" ]; then
    ASSETS_PROVIDED=true
    print_success "Carpeta de assets encontrada: $ASSETS_PATH"
else
    if [ "$HAS_ASSETS" = "true" ]; then
        print_warning "Carpeta de assets no encontrada: $ASSETS_PATH"
        print_message "Los assets se pueden agregar después con: php artisan project:update-assets"
    else
        print_message "Assets no configurados (has_assets: false)"
    fi
fi

echo
print_message "═══════════════════════════════════════════════════════════"
print_message "Resumen de configuración:"
echo
print_message "Nombre del proyecto: ${CYAN}$PROJECT_NAME${NC}"
print_message "Directorio:         ${CYAN}$PROJECT_DIR${NC}"
print_message "Repositorio:        ${CYAN}$REPO_URL${NC}"
if [ "$ASSETS_PROVIDED" = true ]; then
    print_message "Assets:             ${CYAN}$ASSETS_PATH${NC} ✅"
else
    print_message "Assets:             ${CYAN}$ASSETS_PATH${NC} ⚠️  (no encontrado)"
fi
# Confirmar antes de continuar (solo en modo interactivo)
if [ -z "$JSON_FILE" ]; then
    echo
    read -p "¿Continuar con la creación? (y/N): " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        print_message "Operación cancelada"
        exit 0
    fi
fi

echo
print_message "═══════════════════════════════════════════════════════════"
print_step "1. Creando directorio del proyecto..."
mkdir -p "$PROJECT_DIR"
cd "$PROJECT_DIR" || exit 1
print_success "Directorio creado: $PROJECT_DIR"

print_step "2. Inicializando repositorio Git..."
git init >/dev/null 2>&1
print_success "Repositorio Git inicializado"

print_step "3. Configurando remote origin..."
git remote add origin "$REPO_URL" 2>/dev/null || git remote set-url origin "$REPO_URL"
print_success "Remote origin configurado: $REPO_URL"

print_step "4. Ejecutando script de clonado..."
echo
"$CLONE_SCRIPT" "$REPO_URL"

if [ $? -ne 0 ]; then
    print_error "Error durante el proceso de clonado"
    print_message "Revisa los mensajes anteriores para más detalles"
    exit 1
fi

# Configurar permisos de ejecución para scripts del proyecto
print_step "4.5. Configurando permisos de scripts..."
if [ -d "scripts" ]; then
    chmod +x scripts/*.sh 2>/dev/null || true
    print_success "Permisos de scripts configurados"
fi

# Ejecutar setup del proyecto
echo
print_message "═══════════════════════════════════════════════════════════"
print_step "5. Ejecutando setup del proyecto..."
print_message "═══════════════════════════════════════════════════════════"
echo
print_message "Se ejecutará el script setup_cd_project.sh que:"
print_message "  - Instalará dependencias con composer"
print_message "  - Configurará .env"
print_message "  - Generará APP_KEY"
print_message "  - Ejecutará migraciones y seeders"
echo

SETUP_SCRIPT="$PROJECT_DIR/scripts/setup_cd_project.sh"
if [ -f "$SETUP_SCRIPT" ]; then
    chmod +x "$SETUP_SCRIPT"
    cd "$PROJECT_DIR" || exit 1
    "$SETUP_SCRIPT"

    if [ $? -ne 0 ]; then
        print_error "Error durante el setup del proyecto"
        print_message "Revisa los mensajes anteriores para más detalles"
        exit 1
    fi
else
    print_warning "No se encontró el script setup_cd_project.sh"
    print_message "Ejecuta manualmente: cd $PROJECT_DIR && ./scripts/setup_cd_project.sh"
fi

# Procesar assets si están disponibles
if [ "$ASSETS_PROVIDED" = true ]; then
    echo
    print_message "═══════════════════════════════════════════════════════════"
    print_step "6. Procesando assets del proyecto..."
    print_message "═══════════════════════════════════════════════════════════"

    cd "$PROJECT_DIR" || exit 1

    # Directorio destino donde se copiarán los assets (igual que en el servidor)
    TARGET_ASSETS_DIR="$PROJECT_DIR/public/cd-project/assets"
    mkdir -p "$TARGET_ASSETS_DIR"

    # Verificar que hay assets en la fuente
    ASSET_COUNT=0
    for asset in logo.png logo-2.png favicon.ico; do
        if [ -f "$ASSETS_PATH/$asset" ]; then
            ASSET_COUNT=$((ASSET_COUNT + 1))
        fi
    done

    if [ $ASSET_COUNT -ge 1 ]; then
        # Copiar assets directamente a public/cd-project/assets/ (como en el servidor)
        print_step "Copiando assets desde $ASSETS_PATH..."
        print_message "   Hacia: ${CYAN}$TARGET_ASSETS_DIR${NC}"

        # Copiar solo los archivos de assets (no subdirectorios)
        cp "$ASSETS_PATH"/*.png "$TARGET_ASSETS_DIR/" 2>/dev/null || true
        cp "$ASSETS_PATH"/*.ico "$TARGET_ASSETS_DIR/" 2>/dev/null || true
        cp "$ASSETS_PATH"/*.svg "$TARGET_ASSETS_DIR/" 2>/dev/null || true
        cp "$ASSETS_PATH"/*.css "$TARGET_ASSETS_DIR/" 2>/dev/null || true
        cp "$ASSETS_PATH"/*.webmanifest "$TARGET_ASSETS_DIR/" 2>/dev/null || true

        print_success "Assets copiados al proyecto"

        # Ejecutar comando artisan para actualizar assets (igual que en el servidor)
        print_step "Actualizando assets en ubicaciones finales..."
        print_message "   Ejecutando: php artisan project:update-assets $TARGET_ASSETS_DIR --backup --project=\"$PROJECT_NAME\""

        if php artisan project:update-assets "$TARGET_ASSETS_DIR" --backup --project="$PROJECT_NAME"; then
            print_success "Assets actualizados correctamente"
        else
            print_warning "Error al ejecutar project:update-assets"
            print_message "Puedes ejecutarlo manualmente después:"
            print_message "  cd $PROJECT_DIR"
            print_message "  php artisan project:update-assets public/cd-project/assets --backup --project=\"$PROJECT_NAME\""
        fi
    else
        print_warning "No se encontraron assets válidos en: $ASSETS_PATH"
        print_message "   Se esperan al menos: logo.png, logo-2.png, favicon.ico"
    fi
else
    echo
    print_message "═══════════════════════════════════════════════════════════"
    print_step "6. Assets del proyecto (omitido)"
    print_message "═══════════════════════════════════════════════════════════"
    print_message "No se proporcionaron assets. Puedes agregarlos después con:"
    print_message "  cd $PROJECT_DIR"
    print_message "  php artisan project:update-assets [ruta-a-assets] --backup --project=\"$PROJECT_NAME\""
fi

echo
print_message "═══════════════════════════════════════════════════════════"
print_success "¡Proceso completado exitosamente!"
print_message "═══════════════════════════════════════════════════════════"
echo

# Verificación final
print_step "Verificación final..."
cd "$PROJECT_DIR" || exit 1

# Verificar rama
CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
if [ "$CURRENT_BRANCH" == "cd-system" ]; then
    print_success "Rama cd-system activa"
else
    print_warning "Rama actual: $CURRENT_BRANCH (esperado: cd-system)"
fi

# Verificar .gitattributes
if [ -f ".gitattributes" ] && grep -q "merge=ours" .gitattributes; then
    PROTECTION_COUNT=$(grep -c "merge=ours" .gitattributes)
    print_success ".gitattributes configurado con $PROTECTION_COUNT protecciones"
else
    print_warning ".gitattributes no tiene protecciones configuradas"
fi

# Verificar archivos críticos
CRITICAL_FILES=("config/cd-system.php" "config/site.php" "public/cd-project/assets/logo.png")
MISSING=0
for file in "${CRITICAL_FILES[@]}"; do
    if [ ! -f "$file" ]; then
        print_warning "Archivo faltante: $file"
        MISSING=$((MISSING + 1))
    fi
done

if [ $MISSING -eq 0 ]; then
    print_success "Todos los archivos críticos están presentes"
fi

echo
print_message "═══════════════════════════════════════════════════════════"
print_message "✅ Proyecto '$PROJECT_NAME' creado y configurado"
print_message "═══════════════════════════════════════════════════════════"
echo
print_message "📋 Resumen:"
print_message "  • Proyecto clonado desde cd-system"
print_message "  • Dependencias instaladas"
print_message "  • Base de datos configurada"
print_message "  • Migraciones ejecutadas"
if [ "$ASSETS_PROVIDED" = true ]; then
    print_message "  • Assets actualizados"
fi
echo
print_message "🚀 Próximos pasos:"
echo
echo "  1. Iniciar servidor de desarrollo:"
echo "     ${CYAN}cd $PROJECT_DIR${NC}"
echo "     ${CYAN}php artisan serve${NC}"
echo
echo "  2. Acceder al proyecto:"
echo "     ${CYAN}http://127.0.0.1:8000${NC}"
echo
echo "  3. Credenciales de acceso:"
echo "     ${CYAN}Usuario: admin@$PROJECT_NAME.com${NC}"
echo "     ${CYAN}Contraseña: password${NC}"
echo
if [ "$ASSETS_PROVIDED" = false ]; then
    echo "  4. Actualizar assets (si los tienes):"
    echo "     ${CYAN}cd $PROJECT_DIR${NC}"
    echo "     ${CYAN}php artisan project:update-assets [ruta-a-assets] --backup --project=\"$PROJECT_NAME\"${NC}"
    echo
fi
echo "  5. Push inicial (opcional):"
echo "     ${CYAN}cd $PROJECT_DIR${NC}"
echo "     ${CYAN}git push -u origin cd-system${NC}"
echo
print_message "═══════════════════════════════════════════════════════════"